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

start0.0ms (0%)

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

analyze576.0ms (7.1%)

Memory

-72.8MiB live, 280.2MiB allocated; 817ms collecting garbage

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
0%	0%	99.9%	0.1%	0%	0%	0%	1
0%	0%	99.9%	0.1%	0%	0%	0%	2
0%	0%	99.9%	0.1%	0%	0%	0%	3
0%	0%	49.9%	0.1%	0%	49.9%	0%	4
0%	0%	49.9%	0.1%	0%	49.9%	0%	5
0%	0%	49.9%	0.1%	0%	49.9%	0%	6
9.4%	4.7%	45.2%	0.1%	0%	49.9%	0%	7
17.2%	8.6%	41.3%	0.1%	0%	49.9%	0%	8
27.3%	13.7%	36.3%	0.1%	0%	49.9%	0%	9
41%	20.5%	29.4%	0.1%	0%	49.9%	0%	10
48.6%	24.3%	25.6%	0.1%	0%	49.9%	0%	11
57.1%	28.5%	21.4%	0.1%	0%	49.9%	0%	12

Compiler

Compiled 30 to 17 computations (43.3% saved)

sample2.1s (26%)

Memory

50.6MiB live, 2 817.7MiB allocated; 517ms collecting garbage

Samples

1.6s

8 256×

valid

Precisions

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

ival-log: 274.0ms (23.7% of total)

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

ival-hypot: 252.0ms (21.8% of total)

ival-add: 212.0ms (18.3% of total)

ival-atan2: 76.0ms (6.6% of total)

ival-div: 59.0ms (5.1% of total)

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

exact: 6.0ms (0.5% of total)

adjust: 3.0ms (0.3% of total)

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

Bogosity

explain245.0ms (3%)

Memory

0.7MiB live, 530.0MiB allocated; 59ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
133	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(log.f64 base)`
0	-	-	`(*.f64 re re)`
0	-	-	`(atan2.f64 im re)`
0	-	-	`im`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`re`
0	-	-	`(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))`
0	-	-	`(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))`
0	-	-	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))`
0	-	-	`#s(literal 0 binary64)`
0	-	-	`(*.f64 (atan2.f64 im re) #s(literal 0 binary64))`
0	-	-	`(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))`
0	-	-	`(*.f64 (log.f64 base) (log.f64 base))`
0	-	-	`(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))`
0	-	-	`(*.f64 im im)`
0	-	-	`base`
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	118	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	118
↳	`(*.f64 re re)`	overflow	66
↳	`(*.f64 im im)`	overflow	72
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	15	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	15
↳	`(*.f64 re re)`	underflow	59
↳	`(*.f64 im im)`	underflow	61

Confusion

	Predicted +	Predicted -
+	133	0
-	0	123

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	133	0	0
-	0	0	123

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	123
1	133

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

78.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

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

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

ival-add: 10.0ms (19.2% of total)

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

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

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

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

adjust: 0.0ms (0% of total)

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

exact: 0.0ms (0% of total)

preprocess141.0ms (1.7%)

Memory

-25.0MiB live, 251.1MiB allocated; 37ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	76	189
1	226	171
2	1240	128
0	18	26
0	34	20
1	64	18
2	187	14
3	980	12
4	2597	12
5	5226	12
0	8120	7

Stop Event

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

Calls

Call 1

Inputs

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

Outputs

(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (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 (log.f64 (hypot.f64 im re)) (log.f64 base))

Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 28 to 18 computations (35.7% saved)

eval0.0ms (0%)

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

prune1.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	49.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))

Status

Accuracy

Program

▶

49.4%

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

Compiler

Compiled 28 to 18 computations (35.7% saved)

simplify116.0ms (1.4%)

Memory

-6.4MiB live, 182.5MiB allocated; 29ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	2	(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
cost-diff	4	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	5	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	113
0	34	95
1	64	93
2	187	89
3	980	87
4	2597	87
5	5226	85
0	8120	59

Stop Event

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

Calls

Call 1

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

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

localize66.0ms (0.8%)

Memory

8.3MiB live, 106.7MiB allocated; 15ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.35775375976844204	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))
accuracy	0.4147262695368841	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.521816259768442	(*.f64 (log.f64 base) (log.f64 base))
accuracy	30.93770391496002	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

54.0ms

256×

valid

Compiler

Compiled 121 to 20 computations (83.5% saved)

Precisions

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

ival-hypot: 15.0ms (35.2% of total)

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

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

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

ival-atan2: 2.0ms (4.7% of total)

ival-div: 1.0ms (2.3% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series123.0ms (1.5%)

Memory

36.8MiB live, 176.4MiB allocated; 53ms collecting garbage

Counts

6 → 80

Calls

Call 1

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

Outputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
0
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(pow (log base) 2)
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(pow (log (/ 1 base)) 2)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)

Calls

9 calls:

Time	Variable		Point	Expression
53.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
38.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
19.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
3.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
3.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))

simplify208.0ms (2.6%)

Memory

3.7MiB live, 234.5MiB allocated; 44ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	299	1781
1	930	1778
2	3832	1690
0	8789	1566

Stop Event

1×	iter limit
1×	node limit

Counts

80 → 78

Calls

Call 1

Inputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
0
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(pow (log base) 2)
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(pow (log (/ 1 base)) 2)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)

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

rewrite74.0ms (0.9%)

Memory

-6.2MiB live, 84.6MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	74
0	34	56
1	121	54
0	978	34

Stop Event

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

Counts

6 → 234

Calls

Call 1

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

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

eval70.0ms (0.9%)

Memory: 9.5MiB live, 60.7MiB allocated; 11ms collecting garbage
Compiler: Compiled 9 140 to 1 294 computations (85.8% saved)

prune27.0ms (0.3%)

Memory

-14.0MiB live, 31.1MiB allocated; 6ms collecting garbage

Pruning

17 alts after pruning (17 fresh and 0 done)

	Pruned	Kept	Total
New	269	17	286
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	270	17	287

Accuracy

99.9%

Counts

287 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.4%	(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) (log.f64 base))
▶	49.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	4.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (log.f64 (pow.f64 base (log.f64 base))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	23.5%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	49.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 base) (log.f64 im))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.2%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	91.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (fma.f64 (/.f64 (/.f64 (*.f64 re re) im) im) #s(literal 1/2 binary64) (log.f64 im)) (log.f64 base)))
▶	99.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 860 to 578 computations (32.8% saved)

simplify140.0ms (1.7%)

Memory

17.5MiB live, 105.4MiB allocated; 16ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	2	(+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
cost-diff	2	(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
cost-diff	4	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	2	(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
cost-diff	4	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	5	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	5	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	0	(log.f64 base)
cost-diff	0	(log.f64 im)
cost-diff	0	(/.f64 (log.f64 im) (log.f64 base))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
cost-diff	0	(hypot.f64 im re)
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	52	394
0	85	266
1	146	260
2	320	254
3	1580	250
4	4479	250
0	8202	248

Stop Event

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

Calls

Call 1

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

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

localize290.0ms (3.6%)

Memory

-27.6MiB live, 277.3MiB allocated; 102ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.20378876953688405	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.4214403321270288	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.5612679074521062	(pow.f64 (log.f64 base) #s(literal 6 binary64))
accuracy	13.072774442679094	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.16634750976844204	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
accuracy	0.20378876953688405	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.7707916548684018	(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
accuracy	13.072774442679094	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.0	(log.f64 base)
accuracy	0.1484375	(/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.1640625	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.23046875	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(log.f64 im)
accuracy	0.0	(log.f64 base)
accuracy	0.1321576949275739	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
accuracy	0.15625	(/.f64 (log.f64 im) (log.f64 base))
accuracy	0.0	(log.f64 (hypot.f64 im re))
accuracy	0.0	(log.f64 base)
accuracy	0.0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
accuracy	0.16015625	(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))

Samples

74.0ms	140×	0	invalid
36.0ms	116×	0	valid

Compiler

Compiled 433 to 41 computations (90.5% saved)

Precisions

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

ival-mult: 25.0ms (29% of total)

ival-div: 22.0ms (25.5% of total)

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

ival-hypot: 8.0ms (9.3% of total)

ival-pow: 7.0ms (8.1% of total)

ival-add: 5.0ms (5.8% of total)

ival-exp: 2.0ms (2.3% of total)

ival-atan2: 2.0ms (2.3% of total)

ival-pow2: 2.0ms (2.3% of total)

exact: 1.0ms (1.2% of total)

adjust: 0.0ms (0% of total)

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

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

series329.0ms (4.1%)

Memory

7.6MiB live, 391.1MiB allocated; 79ms collecting garbage

Counts

20 → 144

Calls

Call 1

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

Outputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(/ (log im) (pow (log base) 2))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))) (/ (log im) (pow (log base) 2)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 2)))))) (/ (log im) (pow (log base) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (pow (log base) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log base) 2)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 2)))))) (/ (log im) (pow (log base) 2)))
0
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (/ (log (/ 1 re)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (/ (log (/ -1 re)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ (log re) (pow (log base) 2))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))) (/ (log re) (pow (log base) 2)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 2)))))) (/ (log re) (pow (log base) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (pow (log base) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log base) 2)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 2)))))) (/ (log re) (pow (log base) 2)))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (/ (log (/ 1 im)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(+ (log -1) (* -1 (log (/ -1 im))))
(* -1 (/ (log (/ -1 im)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(log base)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log base) 2))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(pow (log base) 2)
(pow (log base) 6)
(pow (log base) 4)
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (log (/ 1 base)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 2))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 6)
(pow (log (/ 1 base)) 4)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (log -1) (* -1 (log (/ -1 base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)

Calls

9 calls:

Time	Variable		Point	Expression
91.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (log base) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (* (log (log base)) 2)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 6) (pow (log base) 4)) (* 0 0)) (pow (log base) 2) (exp (* (log (log base)) 2)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 6) (pow (log base) 4))
66.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (log base) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (* (log (log base)) 2)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 6) (pow (log base) 4)) (* 0 0)) (pow (log base) 2) (exp (* (log (log base)) 2)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 6) (pow (log base) 4))
50.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (log base) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (* (log (log base)) 2)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 6) (pow (log base) 4)) (* 0 0)) (pow (log base) 2) (exp (* (log (log base)) 2)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 6) (pow (log base) 4))
43.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (log base) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (* (log (log base)) 2)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 6) (pow (log base) 4)) (* 0 0)) (pow (log base) 2) (exp (* (log (log base)) 2)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 6) (pow (log base) 4))
40.0ms	im	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (log base) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (* (log (log base)) 2)) (* 0 0))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 6) (pow (log base) 4)) (* 0 0)) (pow (log base) 2) (exp (* (log (log base)) 2)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 6) (pow (log base) 4))

simplify222.0ms (2.7%)

Memory

23.1MiB live, 205.2MiB allocated; 27ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	456	3122
1	1377	3039
2	5618	2841
0	8158	2642

Stop Event

1×	iter limit
1×	node limit

Counts

144 → 142

Calls

Call 1

Inputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(/ (log im) (pow (log base) 2))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))) (/ (log im) (pow (log base) 2)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 2)))))) (/ (log im) (pow (log base) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (pow (log base) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log base) 2)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 2)))))) (/ (log im) (pow (log base) 2)))
0
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (/ (log (/ 1 re)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (/ (log (/ -1 re)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 2))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 2)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ (log re) (pow (log base) 2))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 2)))) (/ (log re) (pow (log base) 2)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (pow (log base) 2)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 2)))))) (/ (log re) (pow (log base) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (pow (log base) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log base) 2)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 2)))))) (/ (log re) (pow (log base) 2)))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (/ (log (/ 1 im)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(+ (log -1) (* -1 (log (/ -1 im))))
(* -1 (/ (log (/ -1 im)) (pow (log base) 2)))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2))))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 2)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 2)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 2)))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(log base)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log base) 2))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(pow (log base) 2)
(pow (log base) 6)
(pow (log base) 4)
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (log (/ 1 base)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 2))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 6)
(pow (log (/ 1 base)) 4)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (log -1) (* -1 (log (/ -1 base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)

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

rewrite41.0ms (0.5%)

Memory

-9.0MiB live, 34.4MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	51	209
0	83	140
0	226	136

Stop Event

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

Counts

20 → 139

Calls

Call 1

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

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

eval38.0ms (0.5%)

Memory: 17.0MiB live, 59.8MiB allocated; 10ms collecting garbage
Compiler: Compiled 12 672 to 1 044 computations (91.8% saved)

prune91.0ms (1.1%)

Memory

-22.1MiB live, 47.9MiB allocated; 18ms collecting garbage

Pruning

21 alts after pruning (19 fresh and 2 done)

	Pruned	Kept	Total
New	306	9	315
Fresh	2	10	12
Picked	3	2	5
Done	0	0	0
Total	311	21	332

Accuracy

100.0%

Counts

332 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.1%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(/.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.4%	(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) (log.f64 base))
	49.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	49.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	4.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
▶	49.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	44.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 base) (log.f64 im))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(.f64 (log.f64 base) (/.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	93.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)) (log.f64 base)))
✓	99.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	49.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 1 140 to 747 computations (34.5% saved)

simplify123.0ms (1.5%)

Memory

1.9MiB live, 140.3MiB allocated; 11ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
cost-diff	0	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
cost-diff	3	(.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	12	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	1	(+.f64 (.f64 re re) (.f64 im im))
cost-diff	2	(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
cost-diff	4	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	1	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
cost-diff	2	(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
cost-diff	2	(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	0	(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
cost-diff	0	(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
cost-diff	4	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
cost-diff	0	(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) (log.f64 base))
cost-diff	6	(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	52	394
0	87	285
1	148	281
2	382	266
3	2551	256
4	7947	256
0	8101	255

Stop Event

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

Calls

Call 1

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

Outputs
(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) (log.f64 base))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base))
(log.f64 (hypot.f64 re im))
(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 base)
base
(log.f64 (hypot.f64 im re))
(log.f64 (hypot.f64 re im))
(hypot.f64 im re)
(hypot.f64 re im)
im
re
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (hypot.f64 re im))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 re im)
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(log.f64 base)
base
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (log.f64 base)) (log.f64 (hypot.f64 re im))) (log.f64 base))
(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64)))
(fma.f64 (log.f64 (hypot.f64 re im)) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 re im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 re im)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 base)
base
#s(approx (* (atan2 im re) 0) #s(literal 0 binary64))
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(literal 0 binary64)
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
(*.f64 (/.f64 (log.f64 base) (log.f64 (pow.f64 base (log.f64 base)))) (log.f64 (hypot.f64 re im)))
(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 re im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 re im)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 base)
base
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
#s(literal 0 binary64)
(atan2.f64 im re)
#s(literal 0 binary64)
(log.f64 (pow.f64 base (log.f64 base)))
(pow.f64 base (log.f64 base))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64))
(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 base)
base
(log.f64 (hypot.f64 im re))
(log.f64 (hypot.f64 re im))
(hypot.f64 im re)
(hypot.f64 re im)
im
re
#s(literal 2 binary64)
(.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (hypot.f64 re im)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))

localize259.0ms (3.2%)

Memory

-16.4MiB live, 320.2MiB allocated; 29ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.35775375976844204	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.4147262695368841	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
accuracy	0.521816259768442	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.529628759768442	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
accuracy	0.35775375976844204	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
accuracy	0.4147262695368841	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	30.93770391496002	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	59.07168255239247	(log.f64 (pow.f64 base (log.f64 base)))
accuracy	0.35775375976844204	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
accuracy	0.4147262695368841	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.521816259768442	(*.f64 (log.f64 base) (log.f64 base))
accuracy	30.93770391496002	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.0	(log.f64 base)
accuracy	0.0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
accuracy	0.37890625	(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
accuracy	30.93770391496002	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0.0	(log.f64 base)
accuracy	0.37890625	(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) (log.f64 base))
accuracy	0.38966752930532605	(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base))
accuracy	0.4147262695368841	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))

Samples

202.0ms

256×

valid

Compiler

Compiled 466 to 35 computations (92.5% saved)

Precisions

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

ival-pow2: 23.0ms (25.5% of total)

ival-pow: 17.0ms (18.9% of total)

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

ival-mult: 10.0ms (11.1% of total)

ival-div: 9.0ms (10% of total)

ival-hypot: 8.0ms (8.9% of total)

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

ival-atan2: 2.0ms (2.2% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series150.0ms (1.9%)

Memory

11.0MiB live, 297.5MiB allocated; 62ms collecting garbage

Counts

23 → 167

Calls

Call 1

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

Outputs
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
0
(pow im 2)
(+ (pow im 2) (pow re 2))
(* (pow (log base) 3) (log im))
(+ (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))) (* (pow (log base) 3) (log im)))
(+ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (pow (log base) 3) (pow im 2))))) (* (pow (log base) 3) (log im)))
(+ (* (pow re 2) (+ (* 1/2 (/ (pow (log base) 3) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow (log base) 3) (pow im 4))) (* 1/6 (/ (* (pow re 2) (pow (log base) 3)) (pow im 6))))))) (* (pow (log base) 3) (log im)))
(* (pow (log base) 2) (pow (log im) 2))
(+ (* (pow (log base) 2) (pow (log im) 2)) (/ (* (pow re 2) (* (pow (log base) 2) (log im))) (pow im 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (* (pow (log base) 3) (log (/ 1 re))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))))
(* (pow (log base) 2) (pow (log (/ 1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ 1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4)))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (pow (log base) 3) (log (/ -1 re))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))))
(* (pow (log base) 2) (pow (log (/ -1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ -1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4)))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* (pow (log base) 3) (log re))
(+ (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))) (* (pow (log base) 3) (log re)))
(+ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (pow (log base) 3) (pow re 2))))) (* (pow (log base) 3) (log re)))
(+ (* (pow im 2) (+ (* 1/2 (/ (pow (log base) 3) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow (log base) 3) (pow re 4))) (* 1/6 (/ (* (pow im 2) (pow (log base) 3)) (pow re 6))))))) (* (pow (log base) 3) (log re)))
(* (pow (log base) 2) (pow (log re) 2))
(+ (* (pow (log base) 2) (pow (log re) 2)) (/ (* (pow im 2) (* (pow (log base) 2) (log re))) (pow re 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (* (pow (log base) 3) (log (/ 1 im))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))))
(* (pow (log base) 2) (pow (log (/ 1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ 1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4)))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (* (pow (log base) 3) (log (/ -1 im))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))))
(* (pow (log base) 2) (pow (log (/ -1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ -1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4)))))
(log (sqrt (+ (pow im 2) (pow re 2))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(log base)
(pow (log base) 2)
(* (pow (log base) 3) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (pow (log base) 2) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (log (/ 1 base)))
(pow (log (/ 1 base)) 2)
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 3)))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (log (/ 1 base)) 2))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (log -1) (* -1 (log (/ -1 base))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))

Calls

9 calls:

Time	Variable		Point	Expression
57.0ms	base	@	-inf	((/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* re re) (* im im))) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (pow base (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow base (log base)))) (pow (log base) 2))
40.0ms	base	@	0	((/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* re re) (* im im))) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (pow base (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow base (log base)))) (pow (log base) 2))
27.0ms	base	@	inf	((/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* re re) (* im im))) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (pow base (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow base (log base)))) (pow (log base) 2))
7.0ms	im	@	0	((/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* re re) (* im im))) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (pow base (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow base (log base)))) (pow (log base) 2))
3.0ms	im	@	inf	((/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* im im) (* re re))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* re re) (* im im))) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (pow base (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow base (log base)))) (pow (log base) 2))

simplify210.0ms (2.6%)

Memory

-7.0MiB live, 262.9MiB allocated; 60ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	606	4167
1	1961	4027
0	8530	3747

Stop Event

1×	iter limit
1×	node limit

Counts

167 → 165

Calls

Call 1

Inputs
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
0
(pow im 2)
(+ (pow im 2) (pow re 2))
(* (pow (log base) 3) (log im))
(+ (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))) (* (pow (log base) 3) (log im)))
(+ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (pow (log base) 3) (pow im 2))))) (* (pow (log base) 3) (log im)))
(+ (* (pow re 2) (+ (* 1/2 (/ (pow (log base) 3) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow (log base) 3) (pow im 4))) (* 1/6 (/ (* (pow re 2) (pow (log base) 3)) (pow im 6))))))) (* (pow (log base) 3) (log im)))
(* (pow (log base) 2) (pow (log im) 2))
(+ (* (pow (log base) 2) (pow (log im) 2)) (/ (* (pow re 2) (* (pow (log base) 2) (log im))) (pow im 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (* (pow (log base) 3) (log (/ 1 re))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))))
(* (pow (log base) 2) (pow (log (/ 1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ 1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4)))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (pow (log base) 3) (log (/ -1 re))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log base) 3)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))))))
(* (pow (log base) 2) (pow (log (/ -1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ -1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4)))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* (pow (log base) 3) (log re))
(+ (* 1/2 (/ (* (pow im 2) (pow (log base) 3)) (pow re 2))) (* (pow (log base) 3) (log re)))
(+ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (pow (log base) 3)) (pow re 4))) (* 1/2 (/ (pow (log base) 3) (pow re 2))))) (* (pow (log base) 3) (log re)))
(+ (* (pow im 2) (+ (* 1/2 (/ (pow (log base) 3) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow (log base) 3) (pow re 4))) (* 1/6 (/ (* (pow im 2) (pow (log base) 3)) (pow re 6))))))) (* (pow (log base) 3) (log re)))
(* (pow (log base) 2) (pow (log re) 2))
(+ (* (pow (log base) 2) (pow (log re) 2)) (/ (* (pow im 2) (* (pow (log base) 2) (log re))) (pow re 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (* (pow (log base) 3) (log (/ 1 im))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))))
(* (pow (log base) 2) (pow (log (/ 1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ 1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4)))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (* (pow (log base) 3) (log (/ -1 im))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2)))))
(+ (* -1 (* (pow (log base) 3) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log base) 3)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log base) 3) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log base) 3)) (pow im 2))))))
(* (pow (log base) 2) (pow (log (/ -1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ -1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4)))))
(log (sqrt (+ (pow im 2) (pow re 2))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(log base)
(pow (log base) 2)
(* (pow (log base) 3) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (pow (log base) 2) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (log (/ 1 base)))
(pow (log (/ 1 base)) 2)
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 3)))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (log (/ 1 base)) 2))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (log -1) (* -1 (log (/ -1 base))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))

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

rewrite58.0ms (0.7%)

Memory

21.9MiB live, 68.0MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	52	247
0	87	183
0	262	179

Stop Event

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

Counts

23 → 159

Calls

Call 1

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

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

eval85.0ms (1.1%)

Memory: 2.4MiB live, 101.4MiB allocated; 19ms collecting garbage
Compiler: Compiled 13 743 to 1 324 computations (90.4% saved)

prune52.0ms (0.6%)

Memory

20.4MiB live, 66.2MiB allocated; 3ms collecting garbage

Pruning

21 alts after pruning (18 fresh and 3 done)

	Pruned	Kept	Total
New	327	7	334
Fresh	3	11	14
Picked	4	1	5
Done	0	2	2
Total	334	21	355

Accuracy

100.0%

Counts

355 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	98.8%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 #s(approx (* (log base) (log (sqrt (+ (* im im) (* re re))))) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.6%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) #s(approx ( (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))))
	99.0%	(/.f64 (/.f64 #s(approx (* (log base) (log (sqrt (+ (* im im) (* re re))))) (*.f64 (log.f64 im) (log.f64 base))) (log.f64 base)) (log.f64 base))
	49.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	49.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	49.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	4.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
	98.8%	(/.f64 #s(approx (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	93.6%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (log.f64 base))
	98.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	44.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 base) (log.f64 im))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.2%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(.f64 (log.f64 base) (/.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
✓	99.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
✓	49.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 1 116 to 768 computations (31.2% saved)

simplify264.0ms (3.3%)

Memory

-43.5MiB live, 302.7MiB allocated; 42ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
cost-diff	0	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
cost-diff	5	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 #s(approx (* (log base) (log (sqrt (+ (* im im) (* re re))))) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
cost-diff	0	(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	3	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	1	(+.f64 (.f64 re re) (.f64 im im))
cost-diff	1	(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64)))
cost-diff	1	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	0	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re)
cost-diff	0	(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
cost-diff	0	#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)))
cost-diff	0	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (log.f64 base))
cost-diff	0	(hypot.f64 im re)
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	2	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	3	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	47	379
0	77	342
1	128	342
2	294	324
3	1071	312
4	3706	312
0	8296	310

Stop Event

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

Calls

Call 1

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

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

localize172.0ms (2.1%)

Memory

21.0MiB live, 209.7MiB allocated; 17ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.4147262695368841	(*.f64 (log.f64 im) (log.f64 base))
accuracy	0.4147262695368841	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
accuracy	0.521816259768442	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.529628759768442	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
accuracy	0.3984375	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.4147262695368841	(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
accuracy	0.521816259768442	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.9532131349487318	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.35775375976844204	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.4147262695368841	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.521816259768442	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	30.93770391496002	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.00390625	(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
accuracy	0.37890625	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (log.f64 base))
accuracy	0.8308332353678883	(/.f64 #s(literal 1/2 binary64) (*.f64 im im))
accuracy	6.809385820264035	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re)
accuracy	0.0	(log.f64 base)
accuracy	0.38900375976844204	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.39291000976844204	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.521816259768442	(pow.f64 (log.f64 base) #s(literal 2 binary64))

Samples

138.0ms

256×

valid

Compiler

Compiled 424 to 40 computations (90.6% saved)

Precisions

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

ival-mult: 41.0ms (50.1% of total)

ival-div: 10.0ms (12.2% of total)

ival-log: 9.0ms (11% of total)

ival-hypot: 8.0ms (9.8% of total)

ival-pow2: 5.0ms (6.1% of total)

ival-add: 3.0ms (3.7% of total)

ival-pow: 3.0ms (3.7% of total)

ival-atan2: 2.0ms (2.4% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series187.0ms (2.3%)

Memory

1.8MiB live, 290.9MiB allocated; 20ms collecting garbage

Counts

23 → 182

Calls

Call 1

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

Outputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(* 1/2 (/ re (pow im 2)))
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(/ (log im) (pow (log base) 3))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))) (/ (log im) (pow (log base) 3)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 3)))))) (/ (log im) (pow (log base) 3)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (pow (log base) 3)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log base) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 3)))))) (/ (log im) (pow (log base) 3)))
(* (pow (log base) 2) (pow (log im) 2))
(+ (* (pow (log base) 2) (pow (log im) 2)) (/ (* (pow re 2) (* (pow (log base) 2) (log im))) (pow im 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* 1/2 (/ (pow re 2) (pow im 2)))
(* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ 1 re)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ 1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ 1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4)))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ -1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ -1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4)))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(/ (log re) (pow (log base) 3))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))) (/ (log re) (pow (log base) 3)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 3)))))) (/ (log re) (pow (log base) 3)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (pow (log base) 3)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log base) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 3)))))) (/ (log re) (pow (log base) 3)))
(* (pow (log base) 2) (pow (log re) 2))
(+ (* (pow (log base) 2) (pow (log re) 2)) (/ (* (pow im 2) (* (pow (log base) 2) (log re))) (pow re 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(/ 1/2 (pow im 2))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ 1 im)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ 1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ 1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4)))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ -1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ -1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4)))))
(* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(log (sqrt (+ (pow im 2) (pow re 2))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log base) 3))
(log base)
(* (pow (log base) 2) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2))
(pow (log base) 2)
(pow (log base) 4)
(/ -1 (log (/ 1 base)))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 3)))
(* -1 (log (/ 1 base)))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (log (/ 1 base)) 2))
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 4)
(* -1 (* (log im) (log (/ 1 base))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))
(+ (log -1) (* -1 (log (/ -1 base))))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)
(* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))

Calls

9 calls:

Time	Variable		Point	Expression
42.0ms	base	@	inf	((/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ 1/2 (* im im)) re) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2) (/ 1/2 (* im im)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 4) (* (log im) (log base)))
32.0ms	base	@	0	((/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ 1/2 (* im im)) re) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2) (/ 1/2 (* im im)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 4) (* (log im) (log base)))
31.0ms	base	@	-inf	((/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ 1/2 (* im im)) re) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2) (/ 1/2 (* im im)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 4) (* (log im) (log base)))
28.0ms	im	@	-inf	((/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ 1/2 (* im im)) re) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2) (/ 1/2 (* im im)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 4) (* (log im) (log base)))
18.0ms	im	@	inf	((/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (log base)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ 1/2 (* im im)) re) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* re re) (* im im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2) (/ 1/2 (* im im)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (pow (log base) 4) (* (log im) (log base)))

simplify207.0ms (2.6%)

Memory

-36.9MiB live, 263.0MiB allocated; 58ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	627	4309
1	1971	4160
0	8384	3884

Stop Event

1×	iter limit
1×	node limit

Counts

182 → 180

Calls

Call 1

Inputs
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(* 1/2 (/ re (pow im 2)))
(* (log base) (log im))
(+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))
(+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(/ (log im) (pow (log base) 3))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))) (/ (log im) (pow (log base) 3)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 3)))))) (/ (log im) (pow (log base) 3)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (pow (log base) 3)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log base) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 3)))))) (/ (log im) (pow (log base) 3)))
(* (pow (log base) 2) (pow (log im) 2))
(+ (* (pow (log base) 2) (pow (log im) 2)) (/ (* (pow re 2) (* (pow (log base) 2) (log im))) (pow im 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 2) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))) (/ (* (pow (log base) 2) (log im)) (pow im 2)))) (* (pow (log base) 2) (pow (log im) 2)))
(* -1 (/ (log (/ 1 re)) (log base)))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* 1/2 (/ (pow re 2) (pow im 2)))
(* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ 1 re)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ 1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ 1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4)))))
(* -1 (/ (log (/ -1 re)) (log base)))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))
(+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 3))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ -1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (* (pow (log base) 2) (pow (log (/ -1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 2) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 re)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4)))))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
(/ (log re) (pow (log base) 3))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 3)))) (/ (log re) (pow (log base) 3)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (pow (log base) 3)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 3)))))) (/ (log re) (pow (log base) 3)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (pow (log base) 3)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log base) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 3)))))) (/ (log re) (pow (log base) 3)))
(* (pow (log base) 2) (pow (log re) 2))
(+ (* (pow (log base) 2) (pow (log re) 2)) (/ (* (pow im 2) (* (pow (log base) 2) (log re))) (pow re 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 2) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))) (* (pow (log base) 2) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))) (/ (* (pow (log base) 2) (log re)) (pow re 2)))) (* (pow (log base) 2) (pow (log re) 2)))
(/ 1/2 (pow im 2))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ 1 im)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ 1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ 1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ 1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4)))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (pow (log base) 3)))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3))))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 3))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 3)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 3)))))))
(* (pow (log base) 2) (pow (log (/ -1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (* (pow (log base) 2) (pow (log (/ -1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 2) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 2) (pow (log (/ -1 im)) 2)) (+ (/ (* (pow (log base) 2) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4)))))
(* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(log (sqrt (+ (pow im 2) (pow re 2))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log base) 3))
(log base)
(* (pow (log base) 2) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2))
(pow (log base) 2)
(pow (log base) 4)
(/ -1 (log (/ 1 base)))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 3)))
(* -1 (log (/ 1 base)))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (log (/ 1 base)) 2))
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 4)
(* -1 (* (log im) (log (/ 1 base))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))
(+ (log -1) (* -1 (log (/ -1 base))))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)
(* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))

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

rewrite75.0ms (0.9%)

Memory

6.4MiB live, 98.8MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	47	256
0	77	228
1	225	228
0	1279	225

Stop Event

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

Counts

23 → 467

Calls

Call 1

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

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

eval178.0ms (2.2%)

Memory: 18.1MiB live, 208.0MiB allocated; 19ms collecting garbage
Compiler: Compiled 29 375 to 3 030 computations (89.7% saved)

prune78.0ms (1%)

Memory

-7.9MiB live, 89.8MiB allocated; 9ms collecting garbage

Pruning

26 alts after pruning (23 fresh and 3 done)

	Pruned	Kept	Total
New	890	18	908
Fresh	8	5	13
Picked	4	1	5
Done	1	2	3
Total	903	26	929

Accuracy

100.0%

Counts

929 → 26

Alt Table

Click to see full alt table

Status	Accuracy	Program
	44.3%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 #s(approx (* (log base) (log (sqrt (+ (* im im) (* re re))))) (.f64 (log.f64 im) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.0%	(/.f64 (/.f64 #s(approx (* (log base) (log (sqrt (+ (* im im) (* re re))))) (*.f64 (log.f64 im) (log.f64 base))) (log.f64 base)) (log.f64 base))
	49.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 re re (.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.4%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) re) im) im) re (log.f64 im))) (log.f64 base))
	42.2%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (*.f64 (pow.f64 (log.f64 base) #s(literal 1/2 binary64)) (pow.f64 (log.f64 base) #s(literal 1/2 binary64))))
✓	93.6%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (log.f64 base))
	41.8%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))
	93.5%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re) (log.f64 im)))) (log.f64 base))
	47.7%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) #s(approx (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 base))
	48.1%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) #s(approx (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (.f64 (-.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (*.f64 re re)))) (log.f64 base))
	3.0%	(/.f64 #s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) #s(approx (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))) (log.f64 base))
	99.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	44.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.8%	(.f64 (/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.1%	(.f64 (.f64 (log.f64 (hypot.f64 re im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.1%	(.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	99.3%	(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	98.9%	(.f64 (log.f64 base) (/.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.9%	(.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(log.f64 (pow.f64 (hypot.f64 re im) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
✓	49.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 2 289 to 758 computations (66.9% saved)

regimes374.0ms (4.6%)

Memory

-8.7MiB live, 83.5MiB allocated; 8ms collecting garbage

Counts

52 → 1

Calls

Call 1

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

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

Calls

5 calls:

300.0ms	(log.f64 base)
35.0ms	im
12.0ms	base
12.0ms	re
11.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))

Results

Accuracy	Segments	Branch
99.4%	1	`(log.f64 base)`
99.4%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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.4%	1	`re`
99.4%	1	`im`
99.4%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes11.0ms (0.1%)

Memory

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

Counts

6 → 1

Calls

Call 1

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

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

Calls

5 calls:

2.0ms	re
2.0ms	im
2.0ms	base
2.0ms	(log.f64 base)
2.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))

Results

Accuracy	Segments	Branch
99.1%	1	`(log.f64 base)`
99.1%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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.1%	1	`re`
99.1%	1	`im`
99.1%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes6.0ms (0.1%)

Memory

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

Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts

1 → 1

Calls

Call 1

Inputs

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

Outputs

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

Calls

5 calls:

1.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))
1.0ms	(log.f64 base)
1.0ms	im
1.0ms	re
1.0ms	base

Results

Accuracy	Segments	Branch
3.0%	1	`(log.f64 base)`
3.0%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (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))))`
3.0%	1	`im`
3.0%	1	`base`
3.0%	1	`re`

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify109.0ms (1.3%)

Memory

-22.3MiB live, 65.5MiB allocated; 19ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	46	97
1	96	95
2	319	83
3	2192	77
4	7082	77

Stop Event

1×	node limit

Calls

Call 1

Inputs

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

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

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

Outputs

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

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

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

derivations554.0ms (6.8%)

Memory

22.3MiB live, 564.8MiB allocated; 138ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	299	1781
1	930	1778
2	3832	1690
0	8789	1566
0	47	256
0	77	228
1	225	228
0	1279	225
0	18	74
0	34	56
1	121	54
0	978	34
0	627	4309
1	1971	4160
0	8384	3884
0	606	4167
1	1961	4027
0	8530	3747

Stop Event

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

Compiler

Compiled 105 to 47 computations (55.2% saved)

preprocess53.0ms (0.7%)

Memory: 12.3MiB live, 97.7MiB allocated; 26ms collecting garbage
Compiler: Compiled 446 to 250 computations (43.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze576.0ms (7.1%)

sample2.1s (26%)

explain245.0ms (3%)

preprocess141.0ms (1.7%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify116.0ms (1.4%)

localize66.0ms (0.8%)

series123.0ms (1.5%)

simplify208.0ms (2.6%)

rewrite74.0ms (0.9%)

eval70.0ms (0.9%)

prune27.0ms (0.3%)

simplify140.0ms (1.7%)

localize290.0ms (3.6%)

series329.0ms (4.1%)

simplify222.0ms (2.7%)

rewrite41.0ms (0.5%)

eval38.0ms (0.5%)

prune91.0ms (1.1%)

simplify123.0ms (1.5%)

localize259.0ms (3.2%)

series150.0ms (1.9%)

simplify210.0ms (2.6%)

rewrite58.0ms (0.7%)

eval85.0ms (1.1%)

prune52.0ms (0.6%)

simplify264.0ms (3.3%)

localize172.0ms (2.1%)

series187.0ms (2.3%)

simplify207.0ms (2.6%)

rewrite75.0ms (0.9%)

eval178.0ms (2.2%)

prune78.0ms (1%)

regimes374.0ms (4.6%)

regimes11.0ms (0.1%)

regimes6.0ms (0.1%)

simplify109.0ms (1.3%)

derivations554.0ms (6.8%)

preprocess53.0ms (0.7%)

end0.0ms (0%)

Profiling