Metrics for math.log/2 on complex, imaginary part

start0.0ms (0%)

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

analyze155.0ms (2.9%)

Memory

-2.5MiB live, 290.7MiB allocated; 20ms 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%	49.9%	0.1%	0%	49.9%	0%	4
0%	0%	49.9%	0.1%	0%	49.9%	0%	5
0%	0%	49.9%	0.1%	0%	49.9%	0%	6
9.4%	4.7%	45.2%	0.1%	0%	49.9%	0%	7
17.2%	8.6%	41.3%	0.1%	0%	49.9%	0%	8
27.3%	13.7%	36.3%	0.1%	0%	49.9%	0%	9
41%	20.5%	29.4%	0.1%	0%	49.9%	0%	10
48.6%	24.3%	25.6%	0.1%	0%	49.9%	0%	11
57.1%	28.5%	21.4%	0.1%	0%	49.9%	0%	12

Compiler

Compiled 30 to 17 computations (43.3% saved)

sample2.5s (45.9%)

Memory

-57.6MiB live, 1 863.6MiB allocated; 2.0s collecting garbage

Samples

2.0s

8 256×

valid

Precisions

Click to see histograms. Total time spent on operations: 1.8s

ival-log: 1.2s (65.5% of total)

ival-mult!: 195.0ms (11% of total)

ival-hypot: 153.0ms (8.6% of total)

ival-atan2: 151.0ms (8.5% of total)

ival-div!: 71.0ms (4% of total)

ival-add!: 23.0ms (1.3% of total)

ival-sub!: 19.0ms (1.1% of total)

adjust: 2.0ms (0.1% of total)

Bogosity

explain241.0ms (4.5%)

Memory

-11.5MiB live, 471.6MiB allocated; 53ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
136	-	0	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
2	-	2	(1.9047301646543153e+140 1.5849681214179007e-175 8.363440554775029e-159)	`(*.f64 (atan2.f64 im re) (log.f64 base))`
0	-	0	-	`(log.f64 base)`
0	-	0	-	`(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`(atan2.f64 im re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))`
0	-	0	-	`(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))`
0	-	0	-	`(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))`
0	-	0	-	`#s(literal 0 binary64)`
0	-	0	-	`(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))`
0	-	0	-	`(*.f64 (log.f64 base) (log.f64 base))`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`base`
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	117	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	117
↳	`(*.f64 re re)`	overflow	66
↳	`(*.f64 im im)`	overflow	67

Confusion

	Predicted +	Predicted -
+	117	19
-	0	120

Precision

1.0

Recall

0.8602941176470589

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	117	0	19
-	0	0	120

Precision?

1.0

Recall?

0.8602941176470589

Freqs

test

number	freq
0	139
1	117

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

70.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-log: 15.0ms (33.7% of total)

ival-mult!: 11.0ms (24.7% of total)

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

ival-atan2: 4.0ms (9% of total)

ival-add!: 2.0ms (4.5% of total)

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

ival-sub!: 1.0ms (2.2% of total)

adjust: 0.0ms (0% of total)

preprocess59.0ms (1.1%)

Memory

-11.6MiB live, 41.1MiB allocated; 15ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	79	153
1	229	133
2	964	86
3	6091	86

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	46.5%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Status

Accuracy

Program

▶

46.5%

(/.f64 (-.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Compiler

Compiled 56 to 36 computations (35.7% saved)

series148.0ms (2.8%)

Memory

17.3MiB live, 254.2MiB allocated; 18ms collecting garbage

Counts

18 → 76

Calls

Call 1

Inputs
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 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)
(*.f64 im im)
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(hole binary64 0))
#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 (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)))) #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 im #s(hole binary64 im))
#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 (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)))) #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 (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

Calls

9 calls:

Time	Variable		Point	Expression
43.0ms	base	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (atan2 im re) im re (log base) base (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
28.0ms	re	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (atan2 im re) im re (log base) base (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
24.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (atan2 im re) im re (log base) base (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
11.0ms	re	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (atan2 im re) im re (log base) base (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
10.0ms	im	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (atan2 im re) im re (log base) base (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite182.0ms (3.4%)

Memory

27.5MiB live, 253.1MiB allocated; 27ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	311	1967
0	334	1741
1	1583	1725
0	8236	1420

Stop Event

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

Counts

94 → 331

Calls

Call 1

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

Outputs
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(log.f64 base)
base
#s(literal 0 binary64)
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 (hypot.f64 re im))
(pow.f64 (hypot.f64 re im) #s(literal 1 binary64))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(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 (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 (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 (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 (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 (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 (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 (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 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)
(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)
(exp.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (neg.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 (neg.f64 im) im) (.f64 (neg.f64 im) im) (.f64 (.f64 re re) (.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))))
(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 (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 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(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 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))))
(+.f64 (.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))))
(*.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))))
#s(literal 0 binary64)
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
#s(literal 0 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (log base)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx re re)
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(literal 0 binary64))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 im #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx im im)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 re #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx (log base) (log.f64 base))
#s(approx base base)
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (log base)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (log base) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (log base)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (log base) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))

eval46.0ms (0.9%)

Memory: -28.2MiB live, 79.9MiB allocated; 27ms collecting garbage
Compiler: Compiled 9 899 to 1 567 computations (84.2% saved)

prune16.0ms (0.3%)

Memory

-12.0MiB live, 33.7MiB allocated; 4ms collecting garbage

Pruning

13 alts after pruning (13 fresh and 0 done)

	Pruned	Kept	Total
New	294	13	307
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	295	13	308

Accuracy

99.8%

Counts

308 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
	82.3%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	86.7%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	82.1%	(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
	46.5%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
▶	46.5%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	46.5%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	25.9%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	19.8%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
▶	19.9%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.0%	(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Compiler

Compiled 874 to 516 computations (41% saved)

series287.0ms (5.4%)

Memory

63.0MiB live, 478.5MiB allocated; 56ms collecting garbage

Counts

46 → 138

Calls

Call 1

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

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(hole binary64 0))
#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 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#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)))) #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 im #s(hole binary64 im))
#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 (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)))) #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 (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (log base))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (log base)))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (log base)))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (log base))))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log base) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(hole binary64 0))
#s(approx (* (pow (log base) 2) 0) #s(hole binary64 0))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (* -1 (log (/ 1 base))))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (* -1 (log (/ 1 base)))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#s(approx (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (log (log base)) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (+ (log -1) (* -1 (log (/ -1 base)))))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log (log base)) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

Calls

9 calls:

Time	Variable		Point	Expression
92.0ms	base	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) im re (log base) base (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (+ (pow (log base) 6) 0) (pow (log base) 6) 6 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0) (pow (log base) 2))
86.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) im re (log base) base (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (+ (pow (log base) 6) 0) (pow (log base) 6) 6 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0) (pow (log base) 2))
54.0ms	base	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) im re (log base) base (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (+ (pow (log base) 6) 0) (pow (log base) 6) 6 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0) (pow (log base) 2))
10.0ms	re	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) im re (log base) base (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (+ (pow (log base) 6) 0) (pow (log base) 6) 6 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0) (pow (log base) 2))
10.0ms	im	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) im re (log base) base (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (+ (pow (log base) 6) 0) (pow (log base) 6) 6 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0) (pow (log base) 2))

rewrite210.0ms (3.9%)

Memory

-5.3MiB live, 223.6MiB allocated; 29ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	431	3502
0	510	2726
1	1942	2709
0	9275	2404

Stop Event

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

Counts

184 → 856

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(literal 0 binary64)
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 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)
(*.f64 im im)
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(log.f64 (neg.f64 (log.f64 base)))
(neg.f64 (log.f64 base))
#s(literal 2 binary64)
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(-.f64 (.f64 (atan2.f64 im re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64)))
(.f64 (atan2.f64 im re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(log.f64 (log.f64 base))
#s(literal 1 binary64)
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
#s(literal 6 binary64)
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(hole binary64 0))
#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 (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#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)))) #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 im #s(hole binary64 im))
#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 (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)))) #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 (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (log base))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (log base)))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (log base)))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (log base))))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log base) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(hole binary64 0))
#s(approx (* (pow (log base) 2) 0) #s(hole binary64 0))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (* -1 (log (/ 1 base))))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (* -1 (log (/ 1 base)))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#s(approx (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (log (log base)) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (exp (* (log (neg (log base))) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (exp (* (log (neg (log base))) 2)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log (neg (log base))) 2) #s(hole binary64 (* 2 (log (neg (+ (log -1) (* -1 (log (/ -1 base)))))))))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (exp (* (log (log base)) 1)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log (log base)) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (+ (pow (log base) 6) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (atan2.f64 im re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base))))
(log.f64 base)
base
(/.f64 (neg.f64 (neg.f64 #s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (neg.f64 #s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (-.f64 (.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (-.f64 (.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
#s(literal 0 binary64)
#s(literal 0 binary64)
(*.f64 (/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 (pow.f64 base (atan2.f64 im re)))
#s(literal 0 binary64)
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 (hypot.f64 re im))
(pow.f64 (hypot.f64 re im) #s(literal 1 binary64))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(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 (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 (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 (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 (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 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)
(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)
(exp.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (neg.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 (neg.f64 im) im) (.f64 (neg.f64 im) im) (.f64 (.f64 re re) (.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))
(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 (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 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.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 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))
(+.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))))
(*.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))))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (-.f64 (.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))
(*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) (log.f64 (log.f64 base)))
(*.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (log.f64 base))))
(/.f64 (+.f64 (pow.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (log.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 (log.f64 base))) (-.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 (log.f64 base)))) (.f64 (log.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 (log.f64 base)))))))
(fma.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64) (log.f64 (log.f64 base)))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)) (log.f64 (log.f64 base)))
(-.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (log.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(-.f64 (log.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (log.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(+.f64 (log.f64 (fabs.f64 (log.f64 base))) (log.f64 (fabs.f64 (log.f64 base))))
(+.f64 (log.f64 (log.f64 base)) (log.f64 (log.f64 base)))
(+.f64 (log.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 (log.f64 base))))
(log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 (log.f64 base)))
(fma.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)) (log.f64 #s(literal -1 binary64)))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (log.f64 base)))
(+.f64 (log.f64 (log.f64 base)) (log.f64 #s(literal -1 binary64)))
(+.f64 #s(literal 0 binary64) (log.f64 (neg.f64 (log.f64 base))))
(log.f64 (neg.f64 (log.f64 base)))
(*.f64 #s(literal -1 binary64) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 #s(literal -1 binary64) (log.f64 base))
(*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) #s(literal -1 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (log.f64 base) (log.f64 base) (*.f64 #s(literal 0 binary64) (log.f64 base)))))
(/.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)))
(neg.f64 (neg.f64 (neg.f64 (log.f64 base))))
(neg.f64 (log.f64 base))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 base)))
(-.f64 #s(literal 0 binary64) (log.f64 base))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (neg.f64 (log.f64 base))))
(+.f64 (cosh.f64 (log.f64 (neg.f64 (log.f64 base)))) (sinh.f64 (log.f64 (neg.f64 (log.f64 base)))))
(log.f64 (pow.f64 (pow.f64 base #s(literal 1 binary64)) #s(literal -1 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) #s(literal 1 binary64)))
(log.f64 (pow.f64 base #s(literal -1 binary64)))
#s(literal 2 binary64)
(*.f64 (/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base))))
(log.f64 base)
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
#s(literal 1 binary64)
(*.f64 (/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (-.f64 (.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(pow.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 6 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 18 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(fma.f64 (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64)))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(pow.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 6 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 18 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(fma.f64 (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64)))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(literal 6 binary64)
(/.f64 (-.f64 (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 12 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (*.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(-.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(pow.f64 (*.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(literal 4 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (-.f64 (.f64 (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (log base)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx re re)
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 im #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx im im)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 re #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx (exp (* (log (log base)) 1)) (log.f64 base))
#s(approx base base)
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (* (log (neg (log base))) 2) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (log (neg (log base))) (log.f64 (neg.f64 (log.f64 base))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (exp (* (log (log base)) 1)) (log.f64 base))
#s(approx (* (log (log base)) 1) (log.f64 (log.f64 base)))
#s(approx (* (log (log base)) 1) (log.f64 (log.f64 base)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (*.f64 #s(literal 1 binary64) (/.f64 (atan2.f64 im re) (log.f64 base))))
#s(approx (/ (atan2 im re) (log base)) (*.f64 #s(literal 1 binary64) (/.f64 (atan2.f64 im re) (log.f64 base))))
#s(approx (exp (* (log (log base)) 1)) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (*.f64 #s(literal 1 binary64) (/.f64 (atan2.f64 im re) (log.f64 base))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (* (log (neg (log base))) 2) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (log (neg (log base))) (log.f64 (neg.f64 (log.f64 base))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (*.f64 #s(literal 1 binary64) (/.f64 (atan2.f64 im re) (log.f64 base))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (exp (* (log (log base)) 1)) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (* (log (log base)) 1) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
#s(approx (* (log (log base)) 1) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (*.f64 #s(literal 1 binary64) (/.f64 (atan2.f64 im re) (log.f64 base))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (atan2 im re) (log base)) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (exp (* (log (log base)) 1)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (* (log (neg (log base))) 2) (log.f64 (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64))))
#s(approx (log (neg (log base))) (log.f64 (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))))
#s(approx (neg (log base)) (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (atan2 im re) (exp (* (log (log base)) 1))) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (* (atan2 im re) (exp (* (log (log base)) 1))) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (exp (* (log (log base)) 1)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (* (log (log base)) 1) (log.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (log (log base)) 1) (log.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 6) 0) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 6 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))
#s(approx (/ (+ (pow (log base) 6) 0) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))

eval188.0ms (3.5%)

Memory: -28.3MiB live, 165.5MiB allocated; 70ms collecting garbage
Compiler: Compiled 42 080 to 3 296 computations (92.2% saved)

prune127.0ms (2.4%)

Memory

-0.2MiB live, 55.8MiB allocated; 9ms collecting garbage

Pruning

22 alts after pruning (21 fresh and 1 done)

	Pruned	Kept	Total
New	1 079	18	1 097
Fresh	5	3	8
Picked	4	1	5
Done	0	0	0
Total	1 088	22	1 110

Accuracy

99.9%

Counts

1 110 → 22

Alt Table

Click to see full alt table

Status	Accuracy	Program
	82.3%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	82.1%	(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
▶	46.3%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	46.4%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	51.8%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.0%	(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
	50.0%	(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	46.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	51.8%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
▶	46.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.5%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	46.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (exp.f64 (log.f64 (log.f64 base))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))))
▶	99.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
▶	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))

Compiler

Compiled 1 665 to 1 026 computations (38.4% saved)

series196.0ms (3.7%)

Memory

14.3MiB live, 197.9MiB allocated; 37ms collecting garbage

Counts

46 → 129

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(atan2.f64 im re)
im
re
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(literal 1 binary64)
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))
(/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base))))
(exp.f64 (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(literal 0 binary64)
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 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)
(*.f64 im im)
(/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 3 binary64)
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(hole binary64 0))
#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 (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)))) #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 im #s(hole binary64 im))
#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 (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)))) #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 (pow (log base) -1)) #s(hole binary64 (log base)))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (exp (log (log base))) #s(hole binary64 (log base)))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(hole binary64 0))
#s(approx (* (pow (log base) 2) 0) #s(hole binary64 0))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ 1 (pow (log base) -1)) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (exp (log (log base))) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (log (log base)) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (pow (log base) -1)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (exp (log (log base))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (log (log base)) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Calls

9 calls:

Time	Variable		Point	Expression
64.0ms	im	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (pow (log base) -1))) (atan2 im re) im re (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (/ 1 (pow (log base) -1)) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (exp (log (log base)))) (* 0 0)) (* (log base) (exp (log (log base)))) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow (pow (log base) 2) 3) (pow (log base) 2) 2 3 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0))
43.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (pow (log base) -1))) (atan2 im re) im re (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (/ 1 (pow (log base) -1)) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (exp (log (log base)))) (* 0 0)) (* (log base) (exp (log (log base)))) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow (pow (log base) 2) 3) (pow (log base) 2) 2 3 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0))
25.0ms	base	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (pow (log base) -1))) (atan2 im re) im re (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (/ 1 (pow (log base) -1)) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (exp (log (log base)))) (* 0 0)) (* (log base) (exp (log (log base)))) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow (pow (log base) 2) 3) (pow (log base) 2) 2 3 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0))
21.0ms	base	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (pow (log base) -1))) (atan2 im re) im re (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (/ 1 (pow (log base) -1)) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (exp (log (log base)))) (* 0 0)) (* (log base) (exp (log (log base)))) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow (pow (log base) 2) 3) (pow (log base) 2) 2 3 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0))
8.0ms	im	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (pow (log base) -1))) (atan2 im re) im re (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (/ 1 (pow (log base) -1)) (atan2 im re)) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (+ (* (log base) (exp (log (log base)))) (* 0 0)) (* (log base) (exp (log (log base)))) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow (pow (log base) 2) 3) (pow (log base) 2) 2 3 (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow (log base) 4) 4 (- 0 (* (pow (log base) 2) 0)) (* (pow (log base) 2) 0))

rewrite186.0ms (3.5%)

Memory

21.5MiB live, 339.8MiB allocated; 50ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	414	3319
0	481	2730
1	1880	2638
0	8966	2333

Stop Event

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

Counts

175 → 699

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(atan2.f64 im re)
im
re
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(literal 1 binary64)
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))
(/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base))))
(exp.f64 (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(literal 0 binary64)
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 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)
(*.f64 im im)
(/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 3 binary64)
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) 0) #s(hole binary64 0))
#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 (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)))) #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 im #s(hole binary64 im))
#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 (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)))) #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 (pow (log base) -1)) #s(hole binary64 (log base)))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (exp (log (log base))) #s(hole binary64 (log base)))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(hole binary64 0))
#s(approx (* (pow (log base) 2) 0) #s(hole binary64 0))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ 1 (pow (log base) -1)) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (exp (log (log base))) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (log (log base)) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (/ 1 (pow (log base) -1))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (pow (log base) -1)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (exp (log (log base))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (log (log base)) #s(hole binary64 (log (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (exp (log (log base)))) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (+ (* (log base) (exp (log (log base)))) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (exp (log (log base)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (log base)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (pow (log base) 2) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (neg.f64 (neg.f64 (atan2.f64 im re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal -1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base))))
(log.f64 base)
#s(literal 1 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base))) #s(literal -1 binary64))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base))))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 base)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 (log.f64 base))))
(exp.f64 (neg.f64 (log.f64 (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base))))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (neg.f64 (neg.f64 (atan2.f64 im re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal -1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 (.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(exp.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base))))
(log.f64 base)
(log.f64 (log.f64 base))
(/.f64 (neg.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
#s(literal 0 binary64)
#s(literal 0 binary64)
(/.f64 (neg.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (fma.f64 (/.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (/.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (/.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))))) (neg.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))) (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (/.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(+.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (/.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
#s(literal 0 binary64)
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 (hypot.f64 re im))
(pow.f64 (hypot.f64 re im) #s(literal 1 binary64))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(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 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 (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 (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 (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 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)
(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)
(exp.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (neg.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 (neg.f64 im) im) (.f64 (neg.f64 im) im) (.f64 (.f64 re re) (.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))
(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 re) (neg.f64 re) (*.f64 im im))
(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 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))
(+.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))))
(*.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))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 (log.f64 base)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 6 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 6 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 3/2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(/.f64 (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(/.f64 (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (sinh.f64 (.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 6 binary64))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)))) (.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (sinh.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 (pow.f64 base #s(literal -1 binary64)) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (pow.f64 base (log.f64 base)))
#s(literal 2 binary64)
#s(literal 3 binary64)
(/.f64 (-.f64 (pow.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 12 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (*.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(-.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(-.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))) (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (sinh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(literal 4 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (exp (log (log base)))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx re re)
#s(approx (/ (atan2 im re) (exp (log (log base)))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 im #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx im im)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 re #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx (/ 1 (pow (log base) -1)) (log.f64 base))
#s(approx (pow (log base) -1) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ 1 (pow (log base) -1)) (log.f64 base))
#s(approx base base)
#s(approx (/ 1 (pow (log base) -1)) (log.f64 base))
#s(approx (log (log base)) (log.f64 (log.f64 base)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (pow (log base) 2) 3) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (- 0 (* (pow (log base) 2) 0)) #s(literal 0 binary64))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ 1 (pow (log base) -1)) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (pow (log base) -1) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ 1 (pow (log base) -1)) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ 1 (pow (log base) -1)) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (log (log base)) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (pow (log base) 2) 3) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ 1 (pow (log base) -1)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (pow (log base) -1) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal -1 binary64)))
#s(approx (/ 1 (pow (log base) -1)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (/ (atan2 im re) (exp (log (log base)))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ 1 (pow (log base) -1)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (log (log base)) (log.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (pow (log base) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (pow (log base) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (/ 1 (pow (log base) -1)) (atan2 im re)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (/ (pow (pow (log base) 2) 3) (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (pow (pow (log base) 2) 3) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 6 binary64)))
#s(approx (pow (log base) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))

eval87.0ms (1.6%)

Memory: -22.0MiB live, 164.4MiB allocated; 80ms collecting garbage
Compiler: Compiled 22 006 to 2 247 computations (89.8% saved)

prune29.0ms (0.5%)

Memory

-20.6MiB live, 80.1MiB allocated; 7ms collecting garbage

Pruning

25 alts after pruning (23 fresh and 2 done)

	Pruned	Kept	Total
New	501	13	514
Fresh	6	10	16
Picked	4	1	5
Done	0	1	1
Total	511	25	536

Accuracy

100.0%

Counts

536 → 25

Alt Table

Click to see full alt table

Status	Accuracy	Program
	82.1%	(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
	46.3%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
	46.3%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
	98.7%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	51.8%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
▶	50.0%	(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/.f64 (.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	51.8%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
▶	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	46.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) #s(literal 0 binary64)))
	97.5%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	46.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)))))
▶	99.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	46.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
✓	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))
▶	99.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))

Compiler

Compiled 1 826 to 1 156 computations (36.7% saved)

series509.0ms (9.5%)

Memory

22.7MiB live, 818.1MiB allocated; 114ms collecting garbage

Counts

35 → 74

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (atan2.f64 im re) #s(literal 1 binary64))
(atan2.f64 im re)
im
re
#s(literal 1 binary64)
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
(/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))
(pow.f64 base (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(exp.f64 #s(literal 2 binary64))
(log.f64 (neg.f64 (log.f64 base)))
(neg.f64 (log.f64 base))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
#s(literal 0 binary64)
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) 1) #s(hole binary64 (atan2 im re)))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* (log base) (atan2 im re)))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* (log base) (atan2 im re)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx im #s(hole binary64 im))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (log base)))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (log base)))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* -1 (* (log (/ 1 base)) (atan2 im re))))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* -1 (* (log (/ 1 base)) (atan2 im re))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (* -1 (log (/ 1 base)))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re)))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re)))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

Calls

9 calls:

Time	Variable		Point	Expression
133.0ms	im	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (/ (atan2 im re) 1) (pow (log base) -1)) (/ (atan2 im re) 1) (atan2 im re) im re 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/ 1 (/ 1 (log base))) (/ 1 (log base)) (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) (log (/ (pow base (atan2 im re)) 1)) (/ (pow base (atan2 im re)) 1) (pow base (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (pow (exp 2) (log (neg (log base)))) (exp 2) (log (neg (log base))) (neg (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 0 (- (pow (log base) 2) 0))
55.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (/ (atan2 im re) 1) (pow (log base) -1)) (/ (atan2 im re) 1) (atan2 im re) im re 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/ 1 (/ 1 (log base))) (/ 1 (log base)) (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) (log (/ (pow base (atan2 im re)) 1)) (/ (pow base (atan2 im re)) 1) (pow base (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (pow (exp 2) (log (neg (log base)))) (exp 2) (log (neg (log base))) (neg (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 0 (- (pow (log base) 2) 0))
52.0ms	base	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (/ (atan2 im re) 1) (pow (log base) -1)) (/ (atan2 im re) 1) (atan2 im re) im re 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/ 1 (/ 1 (log base))) (/ 1 (log base)) (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) (log (/ (pow base (atan2 im re)) 1)) (/ (pow base (atan2 im re)) 1) (pow base (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (pow (exp 2) (log (neg (log base)))) (exp 2) (log (neg (log base))) (neg (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 0 (- (pow (log base) 2) 0))
50.0ms	re	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (/ (atan2 im re) 1) (pow (log base) -1)) (/ (atan2 im re) 1) (atan2 im re) im re 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/ 1 (/ 1 (log base))) (/ 1 (log base)) (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) (log (/ (pow base (atan2 im re)) 1)) (/ (pow base (atan2 im re)) 1) (pow base (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (pow (exp 2) (log (neg (log base)))) (exp 2) (log (neg (log base))) (neg (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 0 (- (pow (log base) 2) 0))
48.0ms	base	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (/ (atan2 im re) 1) (pow (log base) -1)) (/ (atan2 im re) 1) (atan2 im re) im re 1 (pow (log base) -1) (log base) base -1 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/ 1 (/ 1 (log base))) (/ 1 (log base)) (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) (log (/ (pow base (atan2 im re)) 1)) (/ (pow base (atan2 im re)) 1) (pow base (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (pow (exp 2) (log (neg (log base)))) (exp 2) (log (neg (log base))) (neg (log base)) (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 0 (- (pow (log base) 2) 0))

rewrite54.0ms (1%)

Memory

17.0MiB live, 107.0MiB allocated; 11ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	175	1646
0	224	1181
0	532	1181

Stop Event

1×	iter-limit
1×	iter-limit
1×	iter-limit
1×	unsound
1×	iter-limit

Counts

109 → 261

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (atan2.f64 im re) #s(literal 1 binary64))
(atan2.f64 im re)
im
re
#s(literal 1 binary64)
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
(/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64)))
(/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))
(pow.f64 base (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(exp.f64 #s(literal 2 binary64))
(log.f64 (neg.f64 (log.f64 base)))
(neg.f64 (log.f64 base))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
#s(literal 0 binary64)
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) 1) #s(hole binary64 (atan2 im re)))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* (log base) (atan2 im re)))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* (log base) (atan2 im re)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx im #s(hole binary64 im))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (log base)))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (log base) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (log base)))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* -1 (* (log (/ 1 base)) (atan2 im re))))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* -1 (* (log (/ 1 base)) (atan2 im re))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (* -1 (log (/ 1 base)))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (atan2 im re) 1) (pow (log base) -1)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (log (/ (pow base (atan2 im re)) 1)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log (/ (pow base (atan2 im re)) 1)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) #s(hole binary64 (exp (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re)))))
#s(approx (pow base (atan2 im re)) #s(hole binary64 (exp (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re)))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (pow (exp 2) (log (neg (log base)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (log (neg (log base))) #s(hole binary64 (log (neg (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (- (pow (log base) 4) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (- (pow (log base) 2) 0) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) #s(literal 1 binary64))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
(/.f64 (neg.f64 (atan2.f64 im re)) #s(literal -1 binary64))
(/.f64 (atan2.f64 im re) #s(literal 1 binary64))
(atan2.f64 im re)
(/.f64 (neg.f64 (atan2.f64 im re)) #s(literal -1 binary64))
(/.f64 (atan2.f64 im re) #s(literal 1 binary64))
im
re
#s(literal 1 binary64)
(*.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 base)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (log.f64 base))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) #s(literal 1 binary64))
(/.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 #s(literal 1 binary64) (log.f64 base))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(log.f64 base)
(*.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 base)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (log.f64 base) (atan2.f64 im re)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (pow.f64 base (/.f64 (atan2.f64 im re) #s(literal 2 binary64))) (pow.f64 base (/.f64 (atan2.f64 im re) #s(literal 2 binary64))))
(pow.f64 (exp.f64 (log.f64 base)) (atan2.f64 im re))
(pow.f64 base (atan2.f64 im re))
(/.f64 (neg.f64 (pow.f64 base (atan2.f64 im re))) #s(literal -1 binary64))
(/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 base) (atan2.f64 im re)))
(+.f64 (cosh.f64 (.f64 (log.f64 base) (atan2.f64 im re))) (sinh.f64 (.f64 (log.f64 base) (atan2.f64 im re))))
(*.f64 (pow.f64 base (/.f64 (atan2.f64 im re) #s(literal 2 binary64))) (pow.f64 base (/.f64 (atan2.f64 im re) #s(literal 2 binary64))))
(pow.f64 (exp.f64 (log.f64 base)) (atan2.f64 im re))
(pow.f64 base (atan2.f64 im re))
(/.f64 (neg.f64 (pow.f64 base (atan2.f64 im re))) #s(literal -1 binary64))
(/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 base) (atan2.f64 im re)))
(+.f64 (cosh.f64 (.f64 (log.f64 base) (atan2.f64 im re))) (sinh.f64 (.f64 (log.f64 base) (atan2.f64 im re))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
#s(literal 2 binary64)
(/.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (log.f64 base) (atan2.f64 im re)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (atan2.f64 im re) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(fma.f64 (atan2.f64 im re) (log.f64 base) (*.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (log.f64 (hypot.f64 re im))) #s(literal 0 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (pow.f64 (exp.f64 #s(literal 2 binary64)) (/.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (/.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base))))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (log.f64 base)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal 2 binary64))) (log.f64 (neg.f64 (log.f64 base)))))
(exp.f64 #s(literal 2 binary64))
(+.f64 (cosh.f64 #s(literal 2 binary64)) (sinh.f64 #s(literal 2 binary64)))
(log.f64 (neg.f64 (log.f64 base)))
(*.f64 #s(literal -1 binary64) (log.f64 base))
(*.f64 (log.f64 base) #s(literal -1 binary64))
(neg.f64 (log.f64 base))
(-.f64 #s(literal 0 binary64) (log.f64 base))
(log.f64 (pow.f64 base #s(literal -1 binary64)))
(.f64 (/.f64 #s(approx (- ( (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(/.f64 (-.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(/.f64 (-.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
#s(literal 4 binary64)
#s(literal 0 binary64)
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) 1) (atan2.f64 im re))
#s(approx (/ (atan2 im re) 1) (atan2.f64 im re))
#s(approx re re)
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (pow base (atan2 im re)) 1) (pow.f64 base (atan2.f64 im re)))
#s(approx (/ (pow base (atan2 im re)) 1) (pow.f64 base (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx im im)
#s(approx (/ 1 (log base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ 1 (/ 1 (log base))) (log.f64 base))
#s(approx base base)
#s(approx (/ 1 (/ 1 (log base))) (log.f64 base))
#s(approx (/ 1 (log base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (exp 2) (log (neg (log base)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (log (neg (log base))) (log.f64 (neg.f64 (log.f64 base))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ 1 (log base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ 1 (/ 1 (log base))) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ 1 (/ 1 (log base))) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (/ 1 (log base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (/ (pow base (atan2 im re)) 1) (exp.f64 (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) (exp.f64 (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (atan2.f64 im re)))
#s(approx (pow (exp 2) (log (neg (log base)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (log (neg (log base))) (log.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base)))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base)))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ 1 (log base)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal -1 binary64)))
#s(approx (/ 1 (/ 1 (log base))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (/ (atan2 im re) (/ 1 (/ 1 (log base)))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ 1 (/ 1 (log base))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (/ 1 (log base)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal -1 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (/ (pow base (atan2 im re)) 1) (exp.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re))))
#s(approx (/ (pow base (atan2 im re)) 1) (exp.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (pow (exp 2) (log (neg (log base))))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (atan2.f64 im re)))
#s(approx (pow (exp 2) (log (neg (log base)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (log (neg (log base))) (log.f64 (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))))
#s(approx (neg (log base)) (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/.f64 (atan2.f64 im re) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 4 binary64)))
#s(approx (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))

eval33.0ms (0.6%)

Memory: -22.5MiB live, 73.6MiB allocated; 13ms collecting garbage
Compiler: Compiled 8 673 to 680 computations (92.2% saved)

prune29.0ms (0.5%)

Memory

31.3MiB live, 78.4MiB allocated; 3ms collecting garbage

Pruning

25 alts after pruning (22 fresh and 3 done)

	Pruned	Kept	Total
New	242	8	250
Fresh	4	14	18
Picked	4	1	5
Done	0	2	2
Total	250	25	275

Accuracy

100.0%

Counts

275 → 25

Alt Table

Click to see full alt table

Status	Accuracy	Program
	82.1%	(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))
	46.3%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
	98.7%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
	99.2%	(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	50.0%	(/.f64 (log.f64 (pow.f64 base (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/.f64 (.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
✓	51.8%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	99.2%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
	51.8%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) #s(literal 0 binary64))))
	46.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) #s(literal 0 binary64)))
	51.8%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (log.f64 base))))))
	97.5%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	98.8%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	46.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)))))
	46.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
✓	46.0%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))
	99.4%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	46.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
	46.1%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))))

Compiler

Compiled 2 840 to 819 computations (71.2% saved)

regimes76.0ms (1.4%)

Memory

-3.5MiB live, 183.7MiB allocated; 20ms collecting garbage

Accuracy

Total -63.7b remaining (-18518.2%)

Threshold costs -63.7b (-18518.2%)

Counts

53 → 1

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (exp.f64 (log.f64 (log.f64 base)))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
(/.f64 (log.f64 (pow.f64 base (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (/.f64 (atan2.f64 im re) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (log.f64 base))))))
(/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/.f64 (.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) #s(literal 0 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (exp.f64 (log.f64 (log.f64 base))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) #s(literal 0 binary64))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(approx (+ (pow (log base) 4) (- 0 (* (pow (log base) 2) 0))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (+.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (atan2.f64 im re))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx (- 0 ( (pow (log base) 2) 0)) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(/.f64 (.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (+.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (/.f64 (+.f64 (pow.f64 (cosh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (cosh.f64 (log.f64 (log.f64 base))) (cosh.f64 (log.f64 (log.f64 base))) (-.f64 (.f64 (sinh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))) (.f64 (cosh.f64 (log.f64 (log.f64 base))) (sinh.f64 (log.f64 (log.f64 base)))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Calls

5 calls:

16.0ms	im
16.0ms	re
15.0ms	(log.f64 base)
12.0ms	base
12.0ms	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Results

Accuracy	Segments	Branch
99.5%	1	`(log.f64 base)`
99.5%	1	`(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
99.5%	1	`re`
99.5%	1	`im`
99.5%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

derivations25.0ms (0.5%)

Memory

-33.6MiB live, 12.4MiB allocated; 6ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 35 to 22 computations (37.1% saved)

preprocess12.0ms (0.2%)

Memory: 35.6MiB live, 35.6MiB allocated; 0ms collecting garbage
Compiler: Compiled 126 to 80 computations (36.5% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze155.0ms (2.9%)

sample2.5s (45.9%)

explain241.0ms (4.5%)

preprocess59.0ms (1.1%)

series148.0ms (2.8%)

rewrite182.0ms (3.4%)

eval46.0ms (0.9%)

prune16.0ms (0.3%)

series287.0ms (5.4%)

rewrite210.0ms (3.9%)

eval188.0ms (3.5%)

prune127.0ms (2.4%)

series196.0ms (3.7%)

rewrite186.0ms (3.5%)

eval87.0ms (1.6%)

prune29.0ms (0.5%)

series509.0ms (9.5%)

rewrite54.0ms (1%)

eval33.0ms (0.6%)

prune29.0ms (0.5%)

regimes76.0ms (1.4%)

derivations25.0ms (0.5%)

preprocess12.0ms (0.2%)

end0.0ms (0%)

Profiling