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

start0.0ms (0%)

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

analyze244.0ms (5.4%)

Memory

27.5MiB live, 351.4MiB allocated; 61ms 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)

sample1.8s (40.4%)

Memory

16.0MiB live, 2 808.5MiB allocated; 617ms collecting garbage

Samples

1.3s

8 256×

valid

Precisions

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

ival-log: 231.0ms (23.1% of total)

ival-mult: 208.0ms (20.8% of total)

ival-atan2: 164.0ms (16.4% of total)

ival-div: 137.0ms (13.7% of total)

ival-hypot: 136.0ms (13.6% of total)

ival-sub: 78.0ms (7.8% of total)

ival-add: 36.0ms (3.6% of total)

exact: 6.0ms (0.6% of total)

adjust: 3.0ms (0.3% of total)

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

Bogosity

explain369.0ms (8.2%)

Memory

4.5MiB live, 428.8MiB allocated; 62ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
109	-	0	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
1	-	1	(7.931384982976577e+93 -1.7028134096039933e-226 4.5135701717610117e-17)	`(*.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	92	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	92
↳	`(*.f64 re re)`	overflow	53
↳	`(*.f64 im im)`	overflow	55

Confusion

	Predicted +	Predicted -
+	92	17
-	0	147

Precision

1.0

Recall

0.8440366972477065

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	92	0	17
-	0	0	147

Precision?

1.0

Recall?

0.8440366972477065

Freqs

test

number	freq
0	164
1	92

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

99.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-hypot: 35.0ms (45.9% of total)

ival-mult: 15.0ms (19.7% of total)

ival-log: 11.0ms (14.4% of total)

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

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

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

ival-sub: 2.0ms (2.6% of total)

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

adjust: 0.0ms (0% of total)

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

exact: 0.0ms (0% of total)

preprocess199.0ms (4.4%)

Memory

21.5MiB live, 268.8MiB allocated; 41ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	79	153
1	229	133
2	964	86
3	6091	86
0	18	26
0	34	14
1	63	12
2	180	8
3	921	6
4	2477	6
5	5141	6
0	8291	6

Stop Event

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

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))))

Outputs

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

Compiler

Compiled 28 to 18 computations (35.7% saved)

eval0.0ms (0%)

Memory: 0.3MiB live, 0.3MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 3 computations (-∞% saved)

prune1.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	57.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))))

Status

Accuracy

Program

▶

57.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))))

Compiler

Compiled 28 to 18 computations (35.7% saved)

series194.0ms (4.3%)

Memory

-10.8MiB live, 416.4MiB allocated; 56ms 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
56.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))
41.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))
30.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))
14.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))
12.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))

rewrite207.0ms (4.6%)

Memory

-4.1MiB live, 372.8MiB allocated; 69ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	297	1741
1	1547	1725
0	8213	1420

Stop Event

1×	iter limit
1×	node limit

Counts

94 → 337

Calls

Call 1

Inputs
(/ (- (* (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)
#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 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 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 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 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 (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 #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 (pow.f64 (log.f64 base) #s(literal 2 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)) (pow.f64 (log.f64 base) #s(literal 2 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)) (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))
(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 (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 (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 #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 (pow.f64 (log.f64 base) #s(literal 2 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)) (pow.f64 (log.f64 base) #s(literal 2 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)) (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))
(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 (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)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (* (log base) (log 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))) (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)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (* (log base) (log 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 (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)) (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)) (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)))

eval38.0ms (0.8%)

Memory: 21.8MiB live, 114.2MiB allocated; 8ms collecting garbage
Compiler: Compiled 9 973 to 1 574 computations (84.2% saved)

prune20.0ms (0.4%)

Memory

-5.7MiB live, 45.4MiB allocated; 8ms collecting garbage

Pruning

14 alts after pruning (14 fresh and 0 done)

	Pruned	Kept	Total
New	296	14	310
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	297	14	311

Accuracy

99.9%

Counts

311 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
	83.1%	(/.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))))
	87.9%	(/.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.9%	(/.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)))))))
	57.0%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (/.f64 #s(literal 1 binary64) (pow.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))))
	57.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 (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))))))
▶	57.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	31.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) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	5.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))) (log.f64 (pow.f64 base (log.f64 base))))
▶	24.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 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	31.2%	(/.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))))
	31.5%	(/.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.3%	(/.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)))
▶	99.3%	(/.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 956 to 568 computations (40.6% saved)

series262.0ms (5.8%)

Memory

-14.6MiB live, 388.9MiB allocated; 140ms collecting garbage

Counts

38 → 122

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) (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)) (pow.f64 (log.f64 base) #s(literal 2 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 4 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(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 (.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)))
(.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))

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

Calls

9 calls:

Time	Variable		Point	Expression
79.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) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (pow (log base) 2))) (/ (- (pow (log base) 4) 0) (pow (log base) 2)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (pow (log base) 2) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0))
52.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) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (pow (log base) 2))) (/ (- (pow (log base) 4) 0) (pow (log base) 2)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (pow (log base) 2) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0))
42.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) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (pow (log base) 2))) (/ (- (pow (log base) 4) 0) (pow (log base) 2)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (pow (log base) 2) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0))
30.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) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (pow (log base) 2))) (/ (- (pow (log base) 4) 0) (pow (log base) 2)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (pow (log base) 2) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0))
20.0ms	im	@	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) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (/ (- (pow (log base) 4) 0) (pow (log base) 2))) (/ (- (pow (log base) 4) 0) (pow (log base) 2)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (pow (log base) 2) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0))

rewrite271.0ms (6%)

Memory

22.7MiB live, 301.2MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	375	2597
1	1771	2580
0	8909	2275

Stop Event

1×	iter limit
1×	node limit

Counts

160 → 933

Calls

Call 1

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

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

eval94.0ms (2.1%)

Memory: 5.4MiB live, 242.4MiB allocated; 25ms collecting garbage
Compiler: Compiled 27 055 to 2 584 computations (90.4% saved)

prune47.0ms (1%)

Memory

-22.2MiB live, 112.7MiB allocated; 30ms collecting garbage

Pruning

20 alts after pruning (19 fresh and 1 done)

	Pruned	Kept	Total
New	792	18	810
Fresh	8	1	9
Picked	4	1	5
Done	0	0	0
Total	804	20	824

Accuracy

100.0%

Counts

824 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.3%	(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	99.2%	(/.f64 (fma.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	82.7%	(/.f64 (/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (.f64 (neg.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 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	87.9%	(/.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))))
	99.3%	(/.f64 (-.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	56.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))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	44.2%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) #s(approx ( (log (sqrt (+ (* re re) (* im im)))) 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 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
	50.9%	(/.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))) (pow.f64 (log.f64 base) #s(literal 8 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))))
	99.3%	(/.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)))
	44.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 (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)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
▶	99.3%	(/.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 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 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)))))
	99.2%	(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.9%	(*.f64 (/.f64 (log.f64 (/.f64 (pow.f64 base (atan2.f64 im re)) #s(literal 1 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 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) (/.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)))
▶	53.8%	#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 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))

Compiler

Compiled 1 261 to 816 computations (35.3% saved)

series184.0ms (4.1%)

Memory

15.5MiB live, 310.3MiB allocated; 59ms collecting garbage

Counts

36 → 73

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

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

Calls

9 calls:

Time	Variable		Point	Expression
68.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)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (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)) (/ (pow (log base) 4) (pow (log base) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (/ (pow (log base) 4) (pow (log base) 2)) (pow (log base) 4) 4 (pow (log base) 2) 2 (/ (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (- (pow (* (log base) (atan2 im re)) 2) 0) (pow (* (log base) (atan2 im re)) 2) (+ (* (log base) (atan2 im re)) 0))
26.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)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (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)) (/ (pow (log base) 4) (pow (log base) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (/ (pow (log base) 4) (pow (log base) 2)) (pow (log base) 4) 4 (pow (log base) 2) 2 (/ (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (- (pow (* (log base) (atan2 im re)) 2) 0) (pow (* (log base) (atan2 im re)) 2) (+ (* (log base) (atan2 im re)) 0))
24.0ms	im	@	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)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (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)) (/ (pow (log base) 4) (pow (log base) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (/ (pow (log base) 4) (pow (log base) 2)) (pow (log base) 4) 4 (pow (log base) 2) 2 (/ (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (- (pow (* (log base) (atan2 im re)) 2) 0) (pow (* (log base) (atan2 im re)) 2) (+ (* (log base) (atan2 im re)) 0))
21.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)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (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)) (/ (pow (log base) 4) (pow (log base) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (/ (pow (log base) 4) (pow (log base) 2)) (pow (log base) 4) 4 (pow (log base) 2) 2 (/ (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (- (pow (* (log base) (atan2 im re)) 2) 0) (pow (* (log base) (atan2 im re)) 2) (+ (* (log base) (atan2 im re)) 0))
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) (/ 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)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (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)) (/ (pow (log base) 4) (pow (log base) 2))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (atan2 im re)) (/ (pow (log base) 4) (pow (log base) 2)) (pow (log base) 4) 4 (pow (log base) 2) 2 (/ (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (- (pow (* (log base) (atan2 im re)) 2) 0) (+ (* (log base) (atan2 im re)) 0)) (- (pow (* (log base) (atan2 im re)) 2) 0) (pow (* (log base) (atan2 im re)) 2) (+ (* (log base) (atan2 im re)) 0))

rewrite53.0ms (1.2%)

Memory

-24.3MiB live, 67.9MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	146	1227
0	420	1227

Stop Event

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

Counts

109 → 304

Calls

Call 1

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

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

eval30.0ms (0.7%)

Memory: 16.1MiB live, 61.6MiB allocated; 7ms collecting garbage
Compiler: Compiled 10 826 to 756 computations (93% saved)

prune27.0ms (0.6%)

Memory

-2.0MiB live, 46.3MiB allocated; 11ms collecting garbage

Pruning

19 alts after pruning (17 fresh and 2 done)

	Pruned	Kept	Total
New	283	11	294
Fresh	8	6	14
Picked	4	1	5
Done	0	1	1
Total	295	19	314

Accuracy

100.0%

Counts

314 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.2%	(/.f64 (fma.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	87.8%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.3%	(/.f64 (-.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
	99.3%	(/.f64 (*.f64 (log.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))))
	98.8%	(/.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 (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))))))
	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))))
▶	54.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #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)))) (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))) (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
✓	99.3%	(/.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 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 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)))))
▶	99.2%	(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.2%	(.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)))
▶	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) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	54.2%	#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 (pow.f64 (log.f64 base) #s(literal -1/2 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)))
	53.8%	#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.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)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))

Compiler

Compiled 1 156 to 774 computations (33% saved)

series91.0ms (2%)

Memory

-4.7MiB live, 182.7MiB allocated; 21ms collecting garbage

Counts

38 → 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 (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))))
(atan2.f64 im re)
im
re
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(literal 1 binary64)
(/.f64 #s(literal 1 binary64) (log.f64 base))
(log.f64 base)
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))))
(*.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))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
#s(literal -1 binary64)
(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 3 binary64))
#s(literal 3 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 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 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (log.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 (/.f64 #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)))) (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) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))) (atan2.f64 im re)))
(.f64 (/.f64 #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)))) (atan2.f64 im re))
(/.f64 #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 (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/2 binary64))
#s(literal -1/2 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(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 (/ 1 (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) 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 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (pow (log base) 3) (atan2 im re)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#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)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx im #s(hole binary64 im))
#s(approx (/ 1 (/ 1 (log base))) #s(hole binary64 (log base)))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (pow (log base) -1) #s(hole binary64 (/ 1 (log base))))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (log base) 3)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) #s(hole binary64 (log base)))
#s(approx (* (pow (log base) -1/2) (pow (log base) -1/2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (pow (log base) -1/2) #s(hole binary64 (sqrt (/ 1 (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 (/ (- (* (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 (/ 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 base) #s(hole binary64 (* -1 (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) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (pow (log base) 3) (atan2 im re)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (pow (log base) 3) #s(hole binary64 (* -1 (pow (log (/ 1 base)) 3))))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -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)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (pow (log base) -1/2) (pow (log base) -1/2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (pow (log base) -1/2) #s(hole binary64 (* (sqrt (/ 1 (log (/ 1 base)))) (sqrt -1))))
#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) (/ 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 base) #s(hole binary64 (+ (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) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (pow (log base) 3) (atan2 im re)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (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)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (pow (log base) -1/2) (pow (log base) -1/2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (pow (log base) -1/2) #s(hole binary64 (sqrt (/ 1 (+ (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
16.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 (/ 1 (log base)))) (atan2 im re) im re (/ 1 (/ 1 (log base))) 1 (/ 1 (log base)) (log base) base (/ (- (* (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) (pow (log base) -1) -1 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (pow (log base) 3) (atan2 im re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (log base) (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (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/2) (pow (log base) -1/2))) (atan2 im re)) (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (* (pow (log base) -1/2) (pow (log base) -1/2)) (pow (log base) -1/2) -1/2 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0)
11.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 (/ 1 (log base)))) (atan2 im re) im re (/ 1 (/ 1 (log base))) 1 (/ 1 (log base)) (log base) base (/ (- (* (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) (pow (log base) -1) -1 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (pow (log base) 3) (atan2 im re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (log base) (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (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/2) (pow (log base) -1/2))) (atan2 im re)) (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (* (pow (log base) -1/2) (pow (log base) -1/2)) (pow (log base) -1/2) -1/2 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0)
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) (/ 1 (/ 1 (log base)))) (atan2 im re) im re (/ 1 (/ 1 (log base))) 1 (/ 1 (log base)) (log base) base (/ (- (* (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) (pow (log base) -1) -1 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (pow (log base) 3) (atan2 im re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (log base) (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (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/2) (pow (log base) -1/2))) (atan2 im re)) (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (* (pow (log base) -1/2) (pow (log base) -1/2)) (pow (log base) -1/2) -1/2 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0)
10.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 (/ 1 (log base)))) (atan2 im re) im re (/ 1 (/ 1 (log base))) 1 (/ 1 (log base)) (log base) base (/ (- (* (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) (pow (log base) -1) -1 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (pow (log base) 3) (atan2 im re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (log base) (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (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/2) (pow (log base) -1/2))) (atan2 im re)) (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (* (pow (log base) -1/2) (pow (log base) -1/2)) (pow (log base) -1/2) -1/2 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0)
9.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 (/ 1 (log base)))) (atan2 im re) im re (/ 1 (/ 1 (log base))) 1 (/ 1 (log base)) (log base) base (/ (- (* (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) (pow (log base) -1) -1 (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (pow (log base) 4)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (* (pow (log base) 3) (atan2 im re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (log base) (atan2 im re)) (pow (log base) 2) 2 (/ (- (* (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/2) (pow (log base) -1/2))) (atan2 im re)) (/ 1 (* (pow (log base) -1/2) (pow (log base) -1/2))) (* (pow (log base) -1/2) (pow (log base) -1/2)) (pow (log base) -1/2) -1/2 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) 0)

rewrite50.0ms (1.1%)

Memory

22.7MiB live, 68.2MiB allocated; 5ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	161	1309
0	470	1309

Stop Event

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

Counts

112 → 246

Calls

Call 1

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

eval20.0ms (0.5%)

Memory: -9.3MiB live, 36.4MiB allocated; 4ms collecting garbage
Compiler: Compiled 6 698 to 546 computations (91.8% saved)

prune70.0ms (1.6%)

Memory

9.2MiB live, 55.6MiB allocated; 4ms collecting garbage

Pruning

20 alts after pruning (17 fresh and 3 done)

	Pruned	Kept	Total
New	189	10	199
Fresh	5	7	12
Picked	3	2	5
Done	1	1	2
Total	198	20	218

Accuracy

100.0%

Counts

218 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
	87.8%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(/.f64 (-.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
	99.3%	(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.3%	(/.f64 (*.f64 (log.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) (/.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))))
	54.1%	(/.f64 #s(approx (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (.f64 (/.f64 #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)))) (atan2.f64 im re))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) #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 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 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)))))
✓	99.2%	(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.0%	(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(/.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) (* (pow (log base) 2) 0)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(.f64 (/.f64 (/.f64 (.f64 #s(literal 1 binary64) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	54.2%	#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))) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
	54.2%	#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.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) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
✓	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)))
	53.8%	#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.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (atan2.f64 im re)))

Compiler

Compiled 2 400 to 649 computations (73% saved)

regimes111.0ms (2.5%)

Memory

-6.7MiB live, 139.4MiB allocated; 52ms collecting garbage

Accuracy

Total -63.7b remaining (-22040.5%)

Threshold costs -63.7b (-22040.5%)

Counts

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

51.0ms	base
16.0ms	re
15.0ms	(log.f64 base)
13.0ms	im
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)

simplify63.0ms (1.4%)

Memory

4.4MiB live, 50.0MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	22	21
1	58	19
2	229	15
3	1797	13
4	6321	13

Stop Event

1×	node limit

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)))

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)))

derivations30.0ms (0.7%)

Memory

-19.9MiB live, 34.0MiB allocated; 10ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 35 to 22 computations (37.1% saved)

preprocess12.0ms (0.3%)

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%)

analyze244.0ms (5.4%)

sample1.8s (40.4%)

explain369.0ms (8.2%)

preprocess199.0ms (4.4%)

eval0.0ms (0%)

prune1.0ms (0%)

series194.0ms (4.3%)

rewrite207.0ms (4.6%)

eval38.0ms (0.8%)

prune20.0ms (0.4%)

series262.0ms (5.8%)

rewrite271.0ms (6%)

eval94.0ms (2.1%)

prune47.0ms (1%)

series184.0ms (4.1%)

rewrite53.0ms (1.2%)

eval30.0ms (0.7%)

prune27.0ms (0.6%)

series91.0ms (2%)

rewrite50.0ms (1.1%)

eval20.0ms (0.5%)

prune70.0ms (1.6%)

regimes111.0ms (2.5%)

simplify63.0ms (1.4%)

derivations30.0ms (0.7%)

preprocess12.0ms (0.3%)

end0.0ms (0%)

Profiling