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

start0.0ms (0%)

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

analyze240.0ms (3.4%)

Memory

28.0MiB live, 367.6MiB allocated; 43ms 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 (30.8%)

Memory

-87.8MiB live, 2 321.6MiB allocated; 1.2s collecting garbage

Samples

1.7s

8 256×

valid

Precisions

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

ival-hypot: 262.0ms (28.9% of total)

ival-mult: 194.0ms (21.4% of total)

ival-log: 166.0ms (18.3% of total)

ival-add: 132.0ms (14.6% of total)

ival-atan2: 73.0ms (8.1% of total)

ival-div: 62.0ms (6.8% of total)

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

exact: 5.0ms (0.6% of total)

adjust: 3.0ms (0.3% of total)

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

Bogosity

explain329.0ms (4.7%)

Memory

44.6MiB live, 329.3MiB allocated; 16ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
130	-	-	`(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	112	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	112
↳	`(*.f64 re re)`	overflow	63
↳	`(*.f64 im im)`	overflow	67
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	18	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	18
↳	`(*.f64 re re)`	underflow	63
↳	`(*.f64 im im)`	underflow	57

Confusion

	Predicted +	Predicted -
+	130	0
-	0	126

Precision

1.0

Recall

1.0

Confusion?

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

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	126
1	130

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

71.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-mult: 14.0ms (28.7% of total)

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

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

ival-add: 7.0ms (14.3% of total)

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

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

preprocess132.0ms (1.9%)

Memory

-32.6MiB live, 201.3MiB allocated; 18ms 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
▶	50.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

▶

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

simplify136.0ms (2%)

Memory

-9.3MiB live, 136.1MiB allocated; 18ms 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)

localize58.0ms (0.8%)

Memory

19.0MiB live, 65.6MiB allocated; 2ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.3046875	(/.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.33203125	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.5114250488422101	(*.f64 (log.f64 base) (log.f64 base))
accuracy	30.145094051726016	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

47.0ms

256×

valid

Compiler

Compiled 121 to 20 computations (83.5% saved)

Precisions

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

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

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

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

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

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

ival-div: 1.0ms (4.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)

series260.0ms (3.7%)

Memory

11.2MiB live, 221.6MiB allocated; 112ms 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
86.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)))
80.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)))
39.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	@	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)))

simplify169.0ms (2.4%)

Memory

24.3MiB live, 158.9MiB allocated; 21ms 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))

rewrite105.0ms (1.5%)

Memory

20.2MiB live, 77.0MiB allocated; 22ms 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))))

eval52.0ms (0.7%)

Memory: -33.3MiB live, 60.1MiB allocated; 5ms collecting garbage
Compiler: Compiled 9 140 to 1 294 computations (85.8% saved)

prune13.0ms (0.2%)

Memory

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

Pruning

14 alts after pruning (14 fresh and 0 done)

	Pruned	Kept	Total
New	272	14	286
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	273	14	287

Accuracy

99.9%

Counts

287 → 14

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))))
	50.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))))
▶	50.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.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))))
	98.8%	(/.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.0%	(.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.3%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	92.4%	#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.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)))

Compiler

Compiled 724 to 492 computations (32% saved)

simplify100.0ms (1.4%)

Memory

11.1MiB live, 57.7MiB allocated; 2ms collecting garbage

Localize:

Found 20 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	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 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #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	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	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	48	327
0	76	253
1	130	249
2	330	237
3	1930	233
4	5615	233
0	8077	232

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

localize166.0ms (2.4%)

Memory

-2.8MiB live, 97.7MiB allocated; 72ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.502285009768442	(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5114250488422101	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.9212993654118478	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	30.145094051726016	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.3359375	(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
accuracy	0.3483200195368841	(.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.5114250488422101	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.9212993654118478	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.32421875	(/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.33203125	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.5114250488422101	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(log.f64 im)
accuracy	0.0	(log.f64 base)
accuracy	0.2758783805424041	#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.3717575195368841	(/.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.3717575195368841	(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))

Samples

129.0ms

256×

valid

Compiler

Compiled 385 to 37 computations (90.4% saved)

Precisions

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

ival-mult: 64.0ms (59.5% of total)

ival-div: 14.0ms (13% of total)

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

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

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

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

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

ival-pow2: 2.0ms (1.9% 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)

series264.0ms (3.8%)

Memory

-4.5MiB live, 182.8MiB allocated; 23ms collecting garbage

Counts

20 → 168

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

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

Calls

9 calls:

Time	Variable		Point	Expression
60.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 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))))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (pow (log base) 2)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (pow (log base) 4) (/ (pow (log base) 4) (pow (log base) 2)))
52.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 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))))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (pow (log base) 2)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (pow (log base) 4) (/ (pow (log base) 4) (pow (log base) 2)))
38.0ms	re	@	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 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))))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (pow (log base) 2)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (pow (log base) 4) (/ (pow (log base) 4) (pow (log base) 2)))
37.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 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))))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (pow (log base) 2)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (pow (log base) 4) (/ (pow (log base) 4) (pow (log base) 2)))
34.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 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))))) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (pow (log base) 2)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (pow (log base) 4) (/ (pow (log base) 4) (pow (log base) 2)))

simplify177.0ms (2.5%)

Memory

4.3MiB live, 186.4MiB allocated; 40ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	540	3907
1	1626	3808
2	6713	3487
0	8155	3244

Stop Event

1×	iter limit
1×	node limit

Counts

168 → 166

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

rewrite36.0ms (0.5%)

Memory

-5.7MiB live, 40.8MiB allocated; 4ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	48	224
0	76	161
0	222	157

Stop Event

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

Counts

20 → 114

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

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

eval47.0ms (0.7%)

Memory: -9.6MiB live, 89.4MiB allocated; 20ms collecting garbage
Compiler: Compiled 14 800 to 1 359 computations (90.8% saved)

prune24.0ms (0.3%)

Memory

20.5MiB live, 65.6MiB allocated; 3ms collecting garbage

Pruning

21 alts after pruning (18 fresh and 3 done)

	Pruned	Kept	Total
New	395	13	408
Fresh	4	5	9
Picked	2	3	5
Done	0	0	0
Total	401	21	422

Accuracy

100.0%

Counts

422 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	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))))
▶	27.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	50.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.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 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.8%	(/.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 (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 4 binary64)))))
▶	99.0%	(.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.7%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 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))))))
	98.7%	(.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.2%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
✓	99.3%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	98.8%	(.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))))
	54.0%	(.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))))
	98.8%	(.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))))
▶	92.1%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.7%	(.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)))
✓	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)))
▶	50.5%	#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.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)))

Compiler

Compiled 1 004 to 693 computations (31% saved)

simplify191.0ms (2.7%)

Memory

-22.1MiB live, 144.6MiB allocated; 114ms collecting garbage

Localize:

Found 20 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	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 4 binary64)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #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	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 6 binary64)))
cost-diff	3	(.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)))
cost-diff	0	(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
cost-diff	0	(/.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 3 binary64)))
cost-diff	0	#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 binary64))))
cost-diff	0	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
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	(hypot.f64 im re)
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(*.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: 2 (0.0ms)

Iter	Nodes	Cost
0	69	430
0	114	366
1	195	362
2	511	347
3	3248	347
0	8173	347

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

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

localize174.0ms (2.5%)

Memory

0.1MiB live, 243.9MiB allocated; 21ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.27962875976844204	(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
accuracy	0.49565908212702886	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.9670545428741497	(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
accuracy	16.6637166285931	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.181972509768442	(.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)))
accuracy	0.2109375	(/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
accuracy	0.49565908212702886	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.7180807725008541	(pow.f64 (log.f64 base) #s(literal 6 binary64))
accuracy	0.19921875	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.29201127930532605	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.3904076660635144	(pow.f64 (log.f64 base) #s(literal 3 binary64))
accuracy	3.685638561820082	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im 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 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
accuracy	0.203125	(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
accuracy	16.6637166285931	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0.0	(log.f64 base)
accuracy	0.19140625	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.21941376953688402	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.29201127930532605	(pow.f64 (log.f64 base) #s(literal 2 binary64))

Samples

75.0ms	114×	0	invalid
55.0ms	142×	0	valid

Compiler

Compiled 466 to 52 computations (88.8% saved)

Precisions

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

ival-mult: 44.0ms (44% of total)

ival-div: 12.0ms (12% of total)

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

ival-pow: 9.0ms (9% of total)

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

ival-add: 6.0ms (6% of total)

ival-exp: 4.0ms (4% of total)

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

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

exact: 1.0ms (1% of total)

adjust: 0.0ms (0% of total)

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

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

series162.0ms (2.3%)

Memory

-20.5MiB live, 258.9MiB allocated; 37ms collecting garbage

Counts

27 → 187

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

Calls

9 calls:

Time	Variable		Point	Expression
57.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))) (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)))) (* (/ (* (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)) (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (exp (* (log (log base)) 2))) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (* (/ 1/2 (* im im)) re) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4) (exp (* (log (log base)) 2)) (/ (pow (log base) 4) (exp (* (log (log base)) 2))))
30.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))) (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)))) (* (/ (* (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)) (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (exp (* (log (log base)) 2))) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (* (/ 1/2 (* im im)) re) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4) (exp (* (log (log base)) 2)) (/ (pow (log base) 4) (exp (* (log (log base)) 2))))
28.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))) (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)))) (* (/ (* (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)) (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (exp (* (log (log base)) 2))) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (* (/ 1/2 (* im im)) re) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4) (exp (* (log (log base)) 2)) (/ (pow (log base) 4) (exp (* (log (log base)) 2))))
10.0ms	re	@	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))) (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)))) (* (/ (* (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)) (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (exp (* (log (log base)) 2))) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (* (/ 1/2 (* im im)) re) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4) (exp (* (log (log base)) 2)) (/ (pow (log base) 4) (exp (* (log (log base)) 2))))
9.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))) (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)))) (* (/ (* (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)) (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (sqrt (+ (* re re) (* im im))) (* (atan2 im re) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 4) (exp (* (log (log base)) 2))) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (log base) 2) (* (/ 1/2 (* im im)) re) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4) (exp (* (log (log base)) 2)) (/ (pow (log base) 4) (exp (* (log (log base)) 2))))

simplify221.0ms (3.2%)

Memory

21.8MiB live, 267.7MiB allocated; 34ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	573	4182
1	1706	4036
2	7062	3722
0	8163	3472

Stop Event

1×	iter limit
1×	node limit

Counts

187 → 185

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

rewrite37.0ms (0.5%)

Memory

-1.4MiB live, 45.5MiB allocated; 2ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	69	305
0	114	258
0	321	255

Stop Event

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

Counts

27 → 163

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

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

eval85.0ms (1.2%)

Memory: -7.8MiB live, 84.4MiB allocated; 8ms collecting garbage
Compiler: Compiled 13 394 to 1 360 computations (89.8% saved)

prune33.0ms (0.5%)

Memory

3.1MiB live, 56.1MiB allocated; 4ms collecting garbage

Pruning

20 alts after pruning (16 fresh and 4 done)

	Pruned	Kept	Total
New	368	9	377
Fresh	6	7	13
Picked	4	1	5
Done	0	3	3
Total	378	20	398

Accuracy

100.0%

Counts

398 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	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 (.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 4 binary64)))
	98.8%	(/.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))))
▶	98.6%	(.f64 (/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.7%	(.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)))
	98.7%	(.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))))
▶	99.3%	(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
✓	99.3%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	98.8%	(.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.7%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	92.1%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 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))))
	91.7%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 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))))))
	98.7%	(.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)))
	51.3%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.f64 #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))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	47.0%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) #s(approx (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) im) im)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	98.8%	(.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))))
✓	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)))
✓	50.5%	#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.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)))

Compiler

Compiled 1 146 to 784 computations (31.6% saved)

simplify148.0ms (2.1%)

Memory

6.0MiB live, 140.7MiB 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 3 binary64))
cost-diff	3	(.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)))
cost-diff	14	(/.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))))
cost-diff	0	(log.f64 base)
cost-diff	0	(.f64 (log.f64 base) #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)))
cost-diff	0	(/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
cost-diff	3	(.f64 (/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	0	(log.f64 im)
cost-diff	0	(/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))
cost-diff	0	#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64))))
cost-diff	0	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	0	(log.f64 im)
cost-diff	0	#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
cost-diff	2	(.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))))
cost-diff	3	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (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)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	45	303
0	70	300
1	108	300
2	258	275
3	1950	266
4	6073	266
0	8014	266

Stop Event

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

Calls

Call 1

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

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

localize117.0ms (1.7%)

Memory

11.7MiB live, 200.3MiB allocated; 18ms 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)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.47789003907376804	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64))
accuracy	0.5114250488422101	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.7475740235163769	(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64))
accuracy	0.3671875	(/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
accuracy	0.38900375976844204	(.f64 (/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
accuracy	0.9212993654118478	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	1.2564412943518042	(pow.f64 (log.f64 base) #s(literal 6 binary64))
accuracy	0.35546875	(/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))
accuracy	0.38900375976844204	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
accuracy	0.9212993654118478	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	1.0544882935591315	(pow.f64 (log.f64 base) #s(literal 5 binary64))
accuracy	0.27731983313574543	#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
accuracy	0.34375	(.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))))
accuracy	0.38576127930532605	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5114250488422101	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.0	#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
accuracy	0.28125	(/.f64 #s(literal 1 binary64) (log.f64 base))
accuracy	0.34375	(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))

Samples

87.0ms

256×

valid

Compiler

Compiled 356 to 30 computations (91.6% saved)

Precisions

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

ival-pow: 23.0ms (36.5% of total)

ival-log: 14.0ms (22.2% of total)

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

ival-mult: 5.0ms (7.9% of total)

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

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

exact: 1.0ms (1.6% of total)

adjust: 0.0ms (0% of total)

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

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

series374.0ms (5.4%)

Memory

16.2MiB live, 485.9MiB allocated; 134ms collecting garbage

Counts

25 → 230

Calls

Call 1

Inputs
(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.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))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
(log.f64 im)
(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64))))
(/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 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 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(.f64 (log.f64 base) #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)))
(log.f64 base)
(/.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)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64))
(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 5 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 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) 5))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5)))) (/ (log im) (pow (log base) 5)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (pow (log base) 5)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 5)))))) (/ (log im) (pow (log base) 5)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (pow (log base) 5)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log base) 5)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log base) 5)))))) (/ (log im) (pow (log base) 5)))
(* (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 (log base) 4) (pow (log im) 2))
(+ (* (pow (log base) 4) (pow (log im) 2)) (/ (* (pow re 2) (* (pow (log base) 4) (log im))) (pow im 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 4) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))) (/ (* (pow (log base) 4) (log im)) (pow im 2)))) (* (pow (log base) 4) (pow (log im) 2)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 4) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))) (* (pow (log base) 4) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))) (/ (* (pow (log base) 4) (log im)) (pow im 2)))) (* (pow (log base) 4) (pow (log im) 2)))
(* (pow (log base) 3) (pow (log im) 3))
(+ (* (pow re 2) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log im) 2) (pow im 2))) (/ (pow (log im) 2) (pow im 2))))) (* (pow (log base) 3) (pow (log im) 3)))
(+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 3) (+ (* -1/4 (/ (pow (log im) 2) (pow im 4))) (+ (* 1/2 (/ (log im) (pow im 4))) (* (log im) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4))))))))) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log im) 2) (pow im 2))) (/ (pow (log im) 2) (pow im 2)))))) (* (pow (log base) 3) (pow (log im) 3)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* (pow re 2) (* (pow (log base) 3) (+ (* -1/4 (/ (log im) (pow im 6))) (+ (* 1/6 (/ (pow (log im) 2) (pow im 6))) (+ (* 1/2 (/ (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))) (pow im 2))) (* (log im) (- (* 1/3 (/ (log im) (pow im 6))) (* 1/4 (/ 1 (pow im 6)))))))))) (* (pow (log base) 3) (+ (* -1/4 (/ (pow (log im) 2) (pow im 4))) (+ (* 1/2 (/ (log im) (pow im 4))) (* (log im) (+ (* -1/2 (/ (log im) (pow im 4))) (* 1/4 (/ 1 (pow im 4)))))))))) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log im) 2) (pow im 2))) (/ (pow (log im) 2) (pow im 2)))))) (* (pow (log base) 3) (pow (log im) 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 (/ (log (/ 1 re)) (pow (log base) 5)))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 5))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5)))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 5))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5))))))
(+ (* -1 (/ (log (/ 1 re)) (pow (log base) 5))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 5)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5)))))))
(* -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 (log base) 4) (pow (log (/ 1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ 1 re)))) (pow re 2))) (* (pow (log base) 4) (pow (log (/ 1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 4) (pow (log (/ 1 re)) 2)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ 1 re)))) (pow re 2))) (+ (* (pow (log base) 4) (pow (log (/ 1 re)) 2)) (+ (/ (* (pow (log base) 4) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re)))))) (pow re 4)))))
(* -1 (* (pow (log base) 3) (pow (log (/ 1 re)) 3)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 re)) 3))) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ 1 re)) 2))) (* (pow im 2) (pow (log (/ 1 re)) 2)))) (pow re 2)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 re)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 re)) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re))))))) (+ (* -1/2 (* (pow im 4) (log (/ 1 re)))) (* -1/4 (* (pow im 4) (pow (log (/ 1 re)) 2)))))) (pow re 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ 1 re)) 2))) (* (pow im 2) (pow (log (/ 1 re)) 2)))) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 re)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 re)) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ 1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))))))) (+ (* 1/720 (* (pow (log (/ 1 re)) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))) (+ (* 1/4 (* (pow im 6) (log (/ 1 re)))) (* 1/2 (* (pow im 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re))))))))))) (pow re 6)) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 re)) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ 1 re))))))) (+ (* -1/2 (* (pow im 4) (log (/ 1 re)))) (* -1/4 (* (pow im 4) (pow (log (/ 1 re)) 2)))))) (pow re 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ 1 re)) 2))) (* (pow im 2) (pow (log (/ 1 re)) 2)))) (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)) (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) 5)))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 5))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5)))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 5))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5))))))
(+ (* -1 (/ (log (/ -1 re)) (pow (log base) 5))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log base) 5)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log base) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5)))))))
(* -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 (log base) 4) (pow (log (/ -1 re)) 2))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ -1 re)))) (pow re 2))) (* (pow (log base) 4) (pow (log (/ -1 re)) 2)))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 4) (pow (log (/ -1 re)) 2)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4))))
(+ (* -1 (/ (* (pow im 2) (* (pow (log base) 4) (log (/ -1 re)))) (pow re 2))) (+ (* (pow (log base) 4) (pow (log (/ -1 re)) 2)) (+ (/ (* (pow (log base) 4) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))))) (pow re 6)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re)))))) (pow re 4)))))
(* -1 (* (pow (log base) 3) (pow (log (/ -1 re)) 3)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 re)) 3))) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ -1 re)) 2))) (* (pow im 2) (pow (log (/ -1 re)) 2)))) (pow re 2)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 re)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 re)) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re))))))) (+ (* -1/2 (* (pow im 4) (log (/ -1 re)))) (* -1/4 (* (pow im 4) (pow (log (/ -1 re)) 2)))))) (pow re 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ -1 re)) 2))) (* (pow im 2) (pow (log (/ -1 re)) 2)))) (pow re 2))))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 re)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 re)) (+ (* -1/4 (pow im 6)) (* -1/360 (* (log (/ -1 re)) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))))))) (+ (* 1/720 (* (pow (log (/ -1 re)) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6))))) (+ (* 1/4 (* (pow im 6) (log (/ -1 re)))) (* 1/2 (* (pow im 2) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re))))))))))) (pow re 6)) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 re)) (+ (* 1/4 (pow im 4)) (* 1/2 (* (pow im 4) (log (/ -1 re))))))) (+ (* -1/2 (* (pow im 4) (log (/ -1 re)))) (* -1/4 (* (pow im 4) (pow (log (/ -1 re)) 2)))))) (pow re 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow im 2) (pow (log (/ -1 re)) 2))) (* (pow im 2) (pow (log (/ -1 re)) 2)))) (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 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) 5))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log base) 5)))) (/ (log re) (pow (log base) 5)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (pow (log base) 5)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 5)))))) (/ (log re) (pow (log base) 5)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (pow (log base) 5)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log base) 5)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log base) 5)))))) (/ (log re) (pow (log base) 5)))
(* (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))))))))
(* (pow (log base) 4) (pow (log re) 2))
(+ (* (pow (log base) 4) (pow (log re) 2)) (/ (* (pow im 2) (* (pow (log base) 4) (log re))) (pow re 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 4) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))) (/ (* (pow (log base) 4) (log re)) (pow re 2)))) (* (pow (log base) 4) (pow (log re) 2)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 4) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))) (* (pow (log base) 4) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))) (/ (* (pow (log base) 4) (log re)) (pow re 2)))) (* (pow (log base) 4) (pow (log re) 2)))
(* (pow (log base) 3) (pow (log re) 3))
(+ (* (pow im 2) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log re) 2) (pow re 2))) (/ (pow (log re) 2) (pow re 2))))) (* (pow (log base) 3) (pow (log re) 3)))
(+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 3) (+ (* -1/4 (/ (pow (log re) 2) (pow re 4))) (+ (* 1/2 (/ (log re) (pow re 4))) (* (log re) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4))))))))) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log re) 2) (pow re 2))) (/ (pow (log re) 2) (pow re 2)))))) (* (pow (log base) 3) (pow (log re) 3)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* (pow im 2) (* (pow (log base) 3) (+ (* -1/4 (/ (log re) (pow re 6))) (+ (* 1/6 (/ (pow (log re) 2) (pow re 6))) (+ (* 1/2 (/ (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))) (pow re 2))) (* (log re) (- (* 1/3 (/ (log re) (pow re 6))) (* 1/4 (/ 1 (pow re 6)))))))))) (* (pow (log base) 3) (+ (* -1/4 (/ (pow (log re) 2) (pow re 4))) (+ (* 1/2 (/ (log re) (pow re 4))) (* (log re) (+ (* -1/2 (/ (log re) (pow re 4))) (* 1/4 (/ 1 (pow re 4)))))))))) (* (pow (log base) 3) (+ (* 1/2 (/ (pow (log re) 2) (pow re 2))) (/ (pow (log re) 2) (pow re 2)))))) (* (pow (log base) 3) (pow (log re) 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 (/ (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) 5)))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 5))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5)))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 5))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 5)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5))))))
(+ (* -1 (/ (log (/ 1 im)) (pow (log base) 5))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 5)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 5)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5)))))))
(* -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 (log base) 4) (pow (log (/ 1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ 1 im)))) (pow im 2))) (* (pow (log base) 4) (pow (log (/ 1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 4) (pow (log (/ 1 im)) 2)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ 1 im)))) (pow im 2))) (+ (* (pow (log base) 4) (pow (log (/ 1 im)) 2)) (+ (/ (* (pow (log base) 4) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im)))))) (pow im 4)))))
(* -1 (* (pow (log base) 3) (pow (log (/ 1 im)) 3)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 im)) 3))) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ 1 im)) 2))) (* (pow re 2) (pow (log (/ 1 im)) 2)))) (pow im 2)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 im)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 im)) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im))))))) (+ (* -1/2 (* (pow re 4) (log (/ 1 im)))) (* -1/4 (* (pow re 4) (pow (log (/ 1 im)) 2)))))) (pow im 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ 1 im)) 2))) (* (pow re 2) (pow (log (/ 1 im)) 2)))) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ 1 im)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 im)) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ 1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))))))) (+ (* 1/720 (* (pow (log (/ 1 im)) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))) (+ (* 1/4 (* (pow re 6) (log (/ 1 im)))) (* 1/2 (* (pow re 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im))))))))))) (pow im 6)) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ 1 im)) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ 1 im))))))) (+ (* -1/2 (* (pow re 4) (log (/ 1 im)))) (* -1/4 (* (pow re 4) (pow (log (/ 1 im)) 2)))))) (pow im 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ 1 im)) 2))) (* (pow re 2) (pow (log (/ 1 im)) 2)))) (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)) (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))))
(* -1 (/ (log (/ -1 im)) (pow (log base) 5)))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 5))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5)))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 5))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 5)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5))))))
(+ (* -1 (/ (log (/ -1 im)) (pow (log base) 5))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log base) 5)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log base) 5)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log base) 5)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log base) 5))
(* -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 (log base) 4) (pow (log (/ -1 im)) 2))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ -1 im)))) (pow im 2))) (* (pow (log base) 4) (pow (log (/ -1 im)) 2)))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 4) (pow (log (/ -1 im)) 2)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4))))
(+ (* -1 (/ (* (pow re 2) (* (pow (log base) 4) (log (/ -1 im)))) (pow im 2))) (+ (* (pow (log base) 4) (pow (log (/ -1 im)) 2)) (+ (/ (* (pow (log base) 4) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))))) (pow im 6)) (/ (* (pow (log base) 4) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im)))))) (pow im 4)))))
(* -1 (* (pow (log base) 3) (pow (log (/ -1 im)) 3)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 im)) 3))) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ -1 im)) 2))) (* (pow re 2) (pow (log (/ -1 im)) 2)))) (pow im 2)))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 im)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 im)) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im))))))) (+ (* -1/2 (* (pow re 4) (log (/ -1 im)))) (* -1/4 (* (pow re 4) (pow (log (/ -1 im)) 2)))))) (pow im 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ -1 im)) 2))) (* (pow re 2) (pow (log (/ -1 im)) 2)))) (pow im 2))))
(+ (* -1 (* (pow (log base) 3) (pow (log (/ -1 im)) 3))) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 im)) (+ (* -1/4 (pow re 6)) (* -1/360 (* (log (/ -1 im)) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))))))) (+ (* 1/720 (* (pow (log (/ -1 im)) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6))))) (+ (* 1/4 (* (pow re 6) (log (/ -1 im)))) (* 1/2 (* (pow re 2) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im))))))))))) (pow im 6)) (+ (/ (* (pow (log base) 3) (+ (* -1 (* (log (/ -1 im)) (+ (* 1/4 (pow re 4)) (* 1/2 (* (pow re 4) (log (/ -1 im))))))) (+ (* -1/2 (* (pow re 4) (log (/ -1 im)))) (* -1/4 (* (pow re 4) (pow (log (/ -1 im)) 2)))))) (pow im 4)) (/ (* (pow (log base) 3) (+ (* 1/2 (* (pow re 2) (pow (log (/ -1 im)) 2))) (* (pow re 2) (pow (log (/ -1 im)) 2)))) (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 base))
(/ 1 (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log base) 5))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(log base)
(* (pow (log base) 4) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2))
(* (pow (log base) 3) (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 3))
(pow (log base) 2)
(pow (log base) 5)
(pow (log base) 4)
(pow (log base) 6)
(* (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 (/ 1 base)))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (log (/ 1 base)) 5)))
(* -1 (/ (log im) (pow (log (/ 1 base)) 5)))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (log (/ 1 base)))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (log (/ 1 base)) 4))
(* -1 (* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 3) (pow (log (/ 1 base)) 3)))
(pow (log (/ 1 base)) 2)
(* -1 (pow (log (/ 1 base)) 5))
(pow (log (/ 1 base)) 4)
(pow (log (/ 1 base)) 6)
(* (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)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 5))
(/ (log im) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 5))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (log -1) (* -1 (log (/ -1 base))))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 2) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4))
(* (pow (log (sqrt (+ (pow im 2) (pow re 2)))) 3) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 5)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)
(* (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
111.0ms	base	@	inf	((* (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) (pow (log base) 2)) (/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (log im) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (/ 1 (log base)) (pow (log base) 2) (pow (log base) 5) (pow (log base) 4) (pow (log base) 6) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
74.0ms	im	@	-inf	((* (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) (pow (log base) 2)) (/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (log im) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (/ 1 (log base)) (pow (log base) 2) (pow (log base) 5) (pow (log base) 4) (pow (log base) 6) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
61.0ms	base	@	0	((* (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) (pow (log base) 2)) (/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (log im) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (/ 1 (log base)) (pow (log base) 2) (pow (log base) 5) (pow (log base) 4) (pow (log base) 6) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
44.0ms	base	@	-inf	((* (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) (pow (log base) 2)) (/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (log im) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (/ 1 (log base)) (pow (log base) 2) (pow (log base) 5) (pow (log base) 4) (pow (log base) 6) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
33.0ms	im	@	inf	((* (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) (pow (log base) 2)) (/ (log base) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (log im) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (/ 1 (log base)) (pow (log base) 2) (pow (log base) 5) (pow (log base) 4) (pow (log base) 6) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))

simplify253.0ms (3.6%)

Memory

-22.4MiB live, 359.4MiB allocated; 38ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	933	7022
1	3169	6681
0	8347	6255

Stop Event

1×	iter limit
1×	node limit

Counts

230 → 228

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

rewrite62.0ms (0.9%)

Memory

19.8MiB live, 113.2MiB allocated; 5ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	45	249
0	70	245
1	180	234
0	937	234

Stop Event

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

Counts

25 → 315

Calls

Call 1

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

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

eval156.0ms (2.2%)

Memory: -2.6MiB live, 236.3MiB allocated; 78ms collecting garbage
Compiler: Compiled 32 337 to 3 209 computations (90.1% saved)

prune41.0ms (0.6%)

Memory

21.6MiB live, 113.6MiB allocated; 13ms collecting garbage

Pruning

20 alts after pruning (15 fresh and 5 done)

	Pruned	Kept	Total
New	912	9	921
Fresh	5	6	11
Picked	2	3	5
Done	2	2	4
Total	921	20	941

Accuracy

100.0%

Counts

941 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.8%	(/.f64 (.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	98.6%	(.f64 (/.f64 (.f64 (log.f64 base) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.7%	(.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)))
	98.6%	(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
	98.5%	(.f64 (.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.5%	(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	54.9%	(.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
	54.5%	(.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))))
	98.8%	(.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))))
	54.6%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (pow.f64 (log.f64 base) #s(literal 5/2 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	98.7%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	91.7%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.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 3 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))))))
	98.7%	(.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)))
	51.3%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (/.f64 #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))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	47.0%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) #s(approx (/ (+ (* (* (/ 1/2 (* im im)) re) re) (log im)) (pow (log base) 3)) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) im) im)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	98.8%	(.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%	(.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	98.7%	(log.f64 (pow.f64 (hypot.f64 re im) #s(approx (/ (log base) (pow (log base) 2)) (pow.f64 (log.f64 base) #s(literal -1 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)))
✓	99.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)))

Compiler

Compiled 1 906 to 646 computations (66.1% saved)

regimes150.0ms (2.2%)

Memory

-34.2MiB live, 107.2MiB allocated; 31ms collecting garbage

Counts

46 → 1

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

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

Calls

5 calls:

70.0ms	(log.f64 base)
32.0ms	re
11.0ms	base
11.0ms	im
10.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)

regimes10.0ms (0.1%)

Memory

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

Accuracy

Total -31.3b remaining (-4879.1%)

Threshold costs -31.3b (-4879.1%)

Counts

5 → 1

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 im) (log.f64 base)))
(.f64 #s(approx (log (sqrt (+ ( im im) (* re re)))) (log.f64 im)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (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)))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (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	base
2.0ms	im
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.0%	1	`(log.f64 base)`
99.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))))`
99.0%	1	`re`
99.0%	1	`im`
99.0%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify66.0ms (0.9%)

Memory

-1.5MiB live, 44.7MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	26	54
1	63	50
2	241	42
3	1864	38
4	6433	38

Stop Event

1×	node 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)))

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

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

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

derivations204.0ms (2.9%)

Memory

-23.2MiB live, 172.8MiB allocated; 13ms 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×	fuel
1×	iter limit
1×	node limit

Compiler

Compiled 70 to 26 computations (62.9% saved)

preprocess33.0ms (0.5%)

Memory

21.0MiB live, 65.6MiB allocated; 9ms collecting garbage

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 412 to 226 computations (45.1% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze240.0ms (3.4%)

sample2.1s (30.8%)

explain329.0ms (4.7%)

preprocess132.0ms (1.9%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify136.0ms (2%)

localize58.0ms (0.8%)

series260.0ms (3.7%)

simplify169.0ms (2.4%)

rewrite105.0ms (1.5%)

eval52.0ms (0.7%)

prune13.0ms (0.2%)

simplify100.0ms (1.4%)

localize166.0ms (2.4%)

series264.0ms (3.8%)

simplify177.0ms (2.5%)

rewrite36.0ms (0.5%)

eval47.0ms (0.7%)

prune24.0ms (0.3%)

simplify191.0ms (2.7%)

localize174.0ms (2.5%)

series162.0ms (2.3%)

simplify221.0ms (3.2%)

rewrite37.0ms (0.5%)

eval85.0ms (1.2%)

prune33.0ms (0.5%)

simplify148.0ms (2.1%)

localize117.0ms (1.7%)

series374.0ms (5.4%)

simplify253.0ms (3.6%)

rewrite62.0ms (0.9%)

eval156.0ms (2.2%)

prune41.0ms (0.6%)

regimes150.0ms (2.2%)

regimes10.0ms (0.1%)

simplify66.0ms (0.9%)

derivations204.0ms (2.9%)

preprocess33.0ms (0.5%)

end0.0ms (0%)

Profiling