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

start0.0ms (0%)

Memory: 0.2MiB live, 0.2MiB allocated

analyze169.0ms (1.3%)

Memory

12.9MiB live, 325.2MiB allocated

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

Memory

13.9MiB live, 2 125.4MiB allocated

Samples

1.6s

8 256×

valid

Precisions

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

ival-log: 317.0ms (26.4% of total)

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

ival-hypot: 249.0ms (20.7% of total)

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

ival-div: 126.0ms (10.5% of total)

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

ival-true: 7.0ms (0.6% of total)

exact: 6.0ms (0.5% of total)

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

Bogosity

explain320.0ms (2.5%)

Memory

-8.9MiB live, 474.3MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
125	-	-	`(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	113	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	113
↳	`(*.f64 re re)`	overflow	70
↳	`(*.f64 im im)`	overflow	55
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	12	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	12
↳	`(*.f64 re re)`	underflow	54
↳	`(*.f64 im im)`	underflow	73

Confusion

	Predicted +	Predicted -
+	125	0
-	0	131

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	125	0	0
-	0	0	131

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	131
1	125

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

77.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-mult: 16.0ms (29.6% of total)

ival-log: 13.0ms (24% of total)

ival-hypot: 11.0ms (20.3% of total)

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

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

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

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

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

exact: 0.0ms (0% of total)

preprocess220.0ms (1.7%)

Memory

-9.1MiB live, 224.9MiB allocated

Algorithm

1×	egg-herbie

Rules

6 840×	`lower-*.f32`
6 832×	`lower-*.f64`
3 016×	`cube-prod`
2 360×	`lower-/.f32`
2 358×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	76	189
1	144	171
2	238	171
3	459	125
4	851	113
5	1590	113
6	4794	113
7	7463	113
0	18	26
0	33	20
1	42	18
2	47	18
3	57	14
4	66	12
5	67	12
6	120	12
7	328	12
8	1179	12
9	1910	12
10	2409	12
11	2708	12
12	3179	12
13	3898	12
14	4917	12
15	6043	12
16	6389	12
17	6596	12
18	6791	12
19	6998	12
0	8488	8

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 (sqrt.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.5MiB live, 0.5MiB allocated
Compiler: Compiled 0 to 3 computations (-∞% saved)

prune1.0ms (0%)

Memory

1.7MiB live, 1.7MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	52.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 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Status

Accuracy

Program

▶

52.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 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Compiler

Compiled 28 to 18 computations (35.7% saved)

simplify210.0ms (1.7%)

Memory

7.4MiB live, 164.4MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	192	(+.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	320	(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
cost-diff	6784	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	13440	(/.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))))

Rules

6 840×	`lower-*.f32`
6 832×	`lower-*.f64`
3 016×	`cube-prod`
2 360×	`lower-/.f32`
2 358×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	113
0	33	99
1	42	93
2	47	93
3	57	89
4	66	87
5	67	87
6	120	87
7	328	87
8	1179	87
9	1910	87
10	2409	87
11	2708	87
12	3179	87
13	3898	87
14	4917	87
15	6043	87
16	6389	87
17	6596	87
18	6791	87
19	6998	87
0	8488	63

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

localize65.0ms (0.5%)

Memory

-5.7MiB live, 112.1MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.34603500976844204	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
accuracy	0.36947250976844204	(/.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.5420112793053261	(*.f64 (log.f64 base) (log.f64 base))
accuracy	29.08962178038225	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

46.0ms

256×

valid

Compiler

Compiled 121 to 20 computations (83.5% saved)

Precisions

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

ival-log: 8.0ms (29.6% of total)

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

ival-hypot: 4.0ms (14.8% of total)

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

ival-div: 2.0ms (7.4% of total)

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

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

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

exact: 0.0ms (0% of total)

series161.0ms (1.3%)

Memory

8.0MiB live, 205.7MiB allocated

Counts

7 → 168

Calls

Call 1

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

Outputs
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log (sqrt (+ (pow im 2) (pow re 2))))) (taylor 0 base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.f64 (log.f64 base) (log.f64 base)) (patch (.f64 (log.f64 base) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log im)) (taylor 0 re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im))) (taylor 0 re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2)))))) (taylor 0 re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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)))))))) (taylor 0 re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ 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))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log im)) (taylor 0 re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im))) (taylor 0 re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2)))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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)))))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ 1 re)))) (taylor inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))) (taylor inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 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))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ 1 re)))) (taylor inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))) (taylor inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ -1 re)))) (taylor -inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))) (taylor -inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -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)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ -1 re)))) (taylor -inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))) (taylor -inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log re)) (taylor 0 im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re))) (taylor 0 im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2)))))) (taylor 0 im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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)))))))) (taylor 0 im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ 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))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (log base) (log re)) (taylor 0 im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re))) (taylor 0 im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2)))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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)))))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))) (taylor inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 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))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))) (taylor inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt (/.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)))) (patch (/.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)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ -1 im)))) (taylor -inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))) (taylor -inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (+.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))) (patch (+.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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -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)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* (log base) (log (/ -1 im)))) (taylor -inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))) (taylor -inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (patch (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #<representation:binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
73.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (* 0 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (sqrt (+ (* re re) (* im im))) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
47.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (* 0 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (sqrt (+ (* re re) (* im im))) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
22.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (* 0 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (sqrt (+ (* re re) (* im im))) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
2.0ms	re	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (* 0 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (sqrt (+ (* re re) (* im im))) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))
2.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (atan2 im re) 0) (* 0 0) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (sqrt (+ (* re re) (* im im))) (* (log base) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)))

simplify180.0ms (1.4%)

Memory

13.3MiB live, 288.4MiB allocated

Algorithm

1×	egg-herbie

Rules

12 210×	`lower-fma.f64`
12 210×	`lower-fma.f32`
4 836×	`lower-*.f64`
4 836×	`lower-*.f32`
3 926×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	299	2912
1	840	2860
2	2641	2828
3	6330	2818
0	8095	2552

Stop Event

1×	iter limit
1×	node limit

Counts

168 → 164

Calls

Call 1

Inputs
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(pow (log base) 2)
(pow (log base) 2)
(pow (log base) 2)
(pow (log base) 2)
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 base)) 2)
(pow (log (/ 1 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))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log 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)))
0
0
0
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))))))))
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 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)))))))
0
0
0
0
(* -1 (* (log base) (log (/ 1 re))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -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)))))))
0
0
0
0
(* -1 (* (log base) (log (/ -1 re))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))
(+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (* (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)))
0
0
0
0
(* (log base) (log re))
(+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))
(+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))
re
(+ 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)))))))
0
0
0
0
(* -1 (* (log base) (log (/ 1 im))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
im
(* 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)))))))
0
0
0
0
(* -1 (* (log base) (log (/ -1 im))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (* (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))))))

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

rewrite270.0ms (2.1%)

Memory

7.4MiB live, 498.0MiB allocated

Rules

5 018×	`lower-fma.f64`
5 018×	`lower-fma.f32`
3 884×	`lower-*.f32`
3 876×	`lower-*.f64`
2 884×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	75
0	33	61
1	98	55
2	687	55
3	6198	55
0	8221	39

Stop Event

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

Counts

7 → 1 484

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 (atan2.f64 im re) #s(literal 0 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)))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(*.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 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))
(.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base))
(.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base))
(.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))
(.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 #s(literal 1 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(*.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))))
(.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)))
(.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.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 -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 #s(literal 1 binary64) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))))
(.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1 binary64))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (log.f64 base)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (neg.f64 (log.f64 base)))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (log.f64 base))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 10 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 12 binary64))) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))) (log.f64 base))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (log.f64 base))
(/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 9 binary64)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))))
(/.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))))
(neg.f64 (.f64 #s(literal 1 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))))))
(neg.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (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 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (log.f64 base)) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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)) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.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 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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)) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.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 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal -1/2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal -4 binary64)) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (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 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.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 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 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 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (.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)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(fma.f64 (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.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 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.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 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(-.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))) #s(literal -1 binary64)))
(+.f64 (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (.f64 (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64)))))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64)))))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64)))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal -6 binary64))) #s(literal 0 binary64)))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64)))
(+.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
#s(literal 0 binary64)
#s(literal 0 binary64)
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 base) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)))
(.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
(.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 base) (.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)))
(.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) #s(literal 1 binary64)))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base))
(pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64))
(/.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 9 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal 0 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))))
(/.f64 (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 9 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(neg.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 base) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 #s(literal 0 binary64) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(*.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)) (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)))
(.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (.f64 (-.f64 re im) (+.f64 im re)))))
(.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64))))
(.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(.f64 (sqrt.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64)))) (sqrt.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64))))
(.f64 (sqrt.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64)))) (pow.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 (log.f64 (hypot.f64 im re))) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (hypot.f64 im re) (hypot.f64 im re)) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (hypot.f64 im re) #s(literal 1/2 binary64))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))))) (neg.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 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 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))))) (sqrt.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 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 im re))))
(/.f64 (sqrt.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 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (hypot.f64 im re))))
(sqrt.f64 (hypot.f64 im re))
(exp.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))))
(*.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.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)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 6 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 -4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (log.f64 base))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 12 binary64))) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 10 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 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 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))
(*.f64 (/.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 2 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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 2 binary64)) (pow.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 -4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)))
(*.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.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))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(.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 -4 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.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 4 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 1 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)) (/.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 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)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.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 4 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(*.f64 (log.f64 base) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (log.f64 base) (/.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.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 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (neg.f64 (log.f64 base)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (pow.f64 (log.f64 base) #s(literal 12 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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)) (log.f64 base)) (log.f64 base))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (-.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) #s(literal 0 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (-.f64 (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 12 binary64)) (pow.f64 (log.f64 base) #s(literal 10 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 #s(literal 1 binary64) (neg.f64 (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))) (*.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 12 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 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 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal -1 binary64))
(/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 12 binary64))) (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 10 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.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 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.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 2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.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 -4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (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 (pow.f64 (log.f64 base) #s(literal -4 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) #s(literal 0 binary64))
(fma.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 -4 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.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 4 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -4 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(exp.f64 (log.f64 (pow.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)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 base) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)))
(.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))))
(.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
(.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 base) (.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 base) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)))
(.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) #s(literal 1 binary64)))
(.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base))
(pow.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64))
(/.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(/.f64 (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 9 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) #s(literal 0 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))))
(/.f64 (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 9 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))
(neg.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 base) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 6 binary64))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (neg.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.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 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base)) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal -2 binary64)) (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (*.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 #s(literal 0 binary64) (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 2 binary64))))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (hypot.f64 im re)))))

eval231.0ms (1.8%)

Memory: -16.4MiB live, 489.0MiB allocated
Compiler: Compiled 56 873 to 3 284 computations (94.2% saved)

prune44.0ms (0.3%)

Memory

6.3MiB live, 132.6MiB allocated

Pruning

16 alts after pruning (16 fresh and 0 done)

	Pruned	Kept	Total
New	1 632	16	1 648
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	1 633	16	1 649

Accuracy

99.5%

Counts

1 649 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 18 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 12 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.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 12 binary64)) (pow.f64 (log.f64 base) #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	52.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.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))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.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))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.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))))
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.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 4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.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 -4 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	51.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 (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	52.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	94.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))))
▶	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 928 to 640 computations (31% saved)

simplify126.0ms (1%)

Memory

-9.5MiB live, 146.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	320	(.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 -4 binary64))))
cost-diff	6784	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	13184	(/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
cost-diff	26048	(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))
cost-diff	320	(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
cost-diff	6784	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	13184	(/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
cost-diff	13568	(/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64)))
cost-diff	320	(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
cost-diff	6784	(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
cost-diff	12800	(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	13184	(/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
cost-diff	0	(*.f64 (log.f64 base) im)
cost-diff	0	(/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im))
cost-diff	0	(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.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))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))))
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)))

Rules

4 334×	`lower-*.f32`
4 324×	`lower-*.f64`
3 078×	`lower-fma.f32`
3 076×	`lower-fma.f64`
1 648×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	59	560
0	95	453
1	127	431
2	192	431
3	417	416
4	829	406
5	992	406
6	1862	406
7	2743	406
8	3836	406
9	3890	406
10	4341	406
11	4840	406
12	5637	398
13	7354	398
0	8010	318

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

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

localize164.0ms (1.3%)

Memory

23.8MiB live, 306.2MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.5459175293053261	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.9492368774956177	(pow.f64 (log.f64 base) #s(literal -4 binary64))
accuracy	0.9877819826331523	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	29.08962178038225	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.36947250976844204	(/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
accuracy	1.5276750759876832	(pow.f64 (log.f64 base) #s(literal 8 binary64))
accuracy	1.7899117464504946	(pow.f64 (log.f64 base) #s(literal 10 binary64))
accuracy	29.08962178038225	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.36947250976844204	(/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
accuracy	0.5459175293053261	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	1.6444264725295386	(exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	29.08962178038225	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0.3046875	(*.f64 (log.f64 base) im)
accuracy	0.3671875	(/.f64 (log.f64 im) (log.f64 base))
accuracy	0.6183733104084654	(/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im))
accuracy	5.055571290555962	(/.f64 (*.f64 re re) im)
accuracy	0	(log.f64 im)
accuracy	0	(log.f64 base)
accuracy	0.19457773151885582	#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.3671875	(/.f64 (log.f64 im) (log.f64 base))

Samples

103.0ms

256×

valid

Compiler

Compiled 561 to 49 computations (91.3% saved)

Precisions

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

ival-mult: 13.0ms (18% of total)

ival-log: 13.0ms (18% of total)

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

ival-pow: 12.0ms (16.6% of total)

ival-add: 8.0ms (11.1% of total)

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

ival-exp: 3.0ms (4.1% of total)

ival-atan2: 3.0ms (4.1% of total)

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

exact: 1.0ms (1.4% of total)

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

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

series219.0ms (1.7%)

Memory

0.2MiB live, 475.9MiB allocated

Counts

24 → 492

Calls

Call 1

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

Outputs
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor 0 base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor 0 base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor 0 base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor 0 base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 2) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 10) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 10) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 10) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 10) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 8) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 8) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 8) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 8) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 4) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 4) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 4) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log base) 4) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log base) 4)) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log base) 4)) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log base) 4)) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log base) 4)) (taylor 0 base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 2) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 10) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 10) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 10) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 10) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 8) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 8) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 8) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 8) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 4) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 4) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 4) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (log (/ 1 base)) 4) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log (/ 1 base)) 4)) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log (/ 1 base)) 4)) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log (/ 1 base)) 4)) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (log (/ 1 base)) 4)) (taylor inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (patch (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (patch (/.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor -inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor -inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor -inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt 1 (taylor -inf base) (#s(alt (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) (patch (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (.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 -4 binary64)))) (patch (.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 -4 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 10) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 10) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 10) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 10) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 10 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 10 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 8) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 8) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 8) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 8) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 8 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 8 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal 4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal 4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ 1 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)) (taylor -inf base) (#s(alt (pow.f64 (log.f64 base) #s(literal -4 binary64)) (patch (pow.f64 (log.f64 base) #s(literal -4 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ 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))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 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))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf re) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -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)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ 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))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 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))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #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))) (patch #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))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (.f64 (atan2.f64 im re) #s(literal 0 binary64)) (patch (.f64 (atan2.f64 im re) #s(literal 0 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 10 binary64)) (pow.f64 (log.f64 base) #s(literal 8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (patch (/.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 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal -4 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -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)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
55.0ms	base	@	0	((/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* (log base) im)) (* (log base) im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (log (pow (log base) 2))) (* 0 0))) (exp (log (pow (log base) 2))) (* (atan2 im re) 0) (* 0 0) (/ (pow (log base) 10) (pow (log base) 8)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 10) (pow (log base) 8)) (* 0 0))) (* (pow (log base) 4) (pow (log base) -4)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (* 0 0))) (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (/ (* re re) im) (sqrt (+ (* re re) (* im im))) (pow (log base) 2) (pow (log base) 10) (pow (log base) 8) (pow (log base) 4) (pow (log base) -4))
31.0ms	im	@	0	((/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* (log base) im)) (* (log base) im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (log (pow (log base) 2))) (* 0 0))) (exp (log (pow (log base) 2))) (* (atan2 im re) 0) (* 0 0) (/ (pow (log base) 10) (pow (log base) 8)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 10) (pow (log base) 8)) (* 0 0))) (* (pow (log base) 4) (pow (log base) -4)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (* 0 0))) (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (/ (* re re) im) (sqrt (+ (* re re) (* im im))) (pow (log base) 2) (pow (log base) 10) (pow (log base) 8) (pow (log base) 4) (pow (log base) -4))
31.0ms	base	@	-inf	((/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* (log base) im)) (* (log base) im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (log (pow (log base) 2))) (* 0 0))) (exp (log (pow (log base) 2))) (* (atan2 im re) 0) (* 0 0) (/ (pow (log base) 10) (pow (log base) 8)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 10) (pow (log base) 8)) (* 0 0))) (* (pow (log base) 4) (pow (log base) -4)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (* 0 0))) (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (/ (* re re) im) (sqrt (+ (* re re) (* im im))) (pow (log base) 2) (pow (log base) 10) (pow (log base) 8) (pow (log base) 4) (pow (log base) -4))
30.0ms	base	@	inf	((/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* (log base) im)) (* (log base) im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (log (pow (log base) 2))) (* 0 0))) (exp (log (pow (log base) 2))) (* (atan2 im re) 0) (* 0 0) (/ (pow (log base) 10) (pow (log base) 8)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 10) (pow (log base) 8)) (* 0 0))) (* (pow (log base) 4) (pow (log base) -4)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (* 0 0))) (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (/ (* re re) im) (sqrt (+ (* re re) (* im im))) (pow (log base) 2) (pow (log base) 10) (pow (log base) 8) (pow (log base) 4) (pow (log base) -4))
16.0ms	im	@	inf	((/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* (log base) im)) (* (log base) im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (exp (log (pow (log base) 2))) (* 0 0))) (exp (log (pow (log base) 2))) (* (atan2 im re) 0) (* 0 0) (/ (pow (log base) 10) (pow (log base) 8)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (/ (pow (log base) 10) (pow (log base) 8)) (* 0 0))) (* (pow (log base) 4) (pow (log base) -4)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (* 0 0))) (* (pow (log base) 2) (* (pow (log base) 4) (pow (log base) -4))) (/ (* re re) im) (sqrt (+ (* re re) (* im im))) (pow (log base) 2) (pow (log base) 10) (pow (log base) 8) (pow (log base) 4) (pow (log base) -4))

simplify293.0ms (2.3%)

Memory

-19.4MiB live, 339.2MiB allocated

Algorithm

1×	egg-herbie

Rules

14 072×	`lower-fma.f64`
14 072×	`lower-fma.f32`
6 480×	`lower-*.f64`
6 480×	`lower-*.f32`
2 638×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	270	6456
1	689	6303
2	2049	6207
3	7694	6207
0	8051	5769

Stop Event

1×	iter limit
1×	node limit

Counts

492 → 488

Calls

Call 1

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

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

rewrite400.0ms (3.1%)

Memory

12.9MiB live, 292.1MiB allocated

Rules

3 998×	`lower-/.f32`
3 988×	`lower-/.f64`
3 792×	`lower-fma.f32`
3 790×	`lower-fma.f64`
3 050×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	59	281
0	95	203
1	283	193
2	2070	193
0	8225	169

Stop Event

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

Counts

24 → 1 339

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

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

eval686.0ms (5.4%)

Memory: 21.0MiB live, 724.4MiB allocated
Compiler: Compiled 80 085 to 5 387 computations (93.3% saved)

prune151.0ms (1.2%)

Memory

5.8MiB live, 260.2MiB allocated

Pruning

25 alts after pruning (24 fresh and 1 done)

	Pruned	Kept	Total
New	2 462	23	2 485
Fresh	10	1	11
Picked	4	1	5
Done	0	0	0
Total	2 476	25	2 501

Accuracy

99.7%

Counts

2 501 → 25

Alt Table

Click to see full alt table

Status	Accuracy	Program
	52.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 10 binary64)) (pow.f64 (log.f64 base) #s(literal -8 binary64))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) re) (/.f64 re im))))
▶	99.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))))
	90.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 (log.f64 base) im) im)) (/.f64 (log.f64 im) (log.f64 base))))
	93.9%	#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) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (.f64 (.f64 (log.f64 base) im) (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 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
▶	98.2%	#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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im)))
	50.2%	#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 re re) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (.f64 (log.f64 base) im) im) (log.f64 im))) (.f64 (.f64 (.f64 (log.f64 base) im) im) (log.f64 base))))
	47.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
	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) (/.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
	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) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	47.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) (exp.f64 (log.f64 (log.f64 base)))))
▶	93.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))))
	98.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 base) im) (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (*.f64 im (log.f64 im))))))
	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
	94.5%	#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) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (log.f64 base) im) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (.f64 (*.f64 (log.f64 base) im) (/.f64 (log.f64 base) (log.f64 im))))))
	99.0%	#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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (.f64 im (/.f64 (log.f64 base) (log.f64 im))))))
	98.1%	#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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (pow.f64 (.f64 (log.f64 base) im) #s(literal -1 binary64))))
	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im)))
	48.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))))
▶	50.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))))
	49.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 (log.f64 base) re)) (/.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) im)) (.f64 re re))))
▶	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))))

Compiler

Compiled 960 to 681 computations (29.1% saved)

simplify220.0ms (1.7%)

Memory

-6.6MiB live, 259.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))))
cost-diff	640	(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))
cost-diff	6720	(fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))
cost-diff	13440	(/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))
cost-diff	0	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re)
cost-diff	0	(.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) re) re)
cost-diff	0	#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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im)))
cost-diff	13440	(fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im)))
cost-diff	0	(fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base))))
cost-diff	0	(/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))
cost-diff	0	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))))
cost-diff	0	(*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)
cost-diff	0	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 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))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))))
cost-diff	384	(.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))
cost-diff	0	(*.f64 (log.f64 base) im)
cost-diff	0	(/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))))
cost-diff	6720	(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))

Rules

15 804×	`lower-fma.f32`
15 796×	`lower-fma.f64`
6 278×	`lower-*.f32`
6 248×	`lower-*.f64`
2 068×	`distribute-lft-in`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	67	690
0	106	626
1	179	612
2	347	612
3	837	583
4	2496	551
5	3587	551
6	3932	551
7	5179	551
8	5254	551
9	5268	551
10	5765	551
11	6408	551
12	7648	551
0	8781	518

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

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

localize180.0ms (1.4%)

Memory

17.2MiB live, 458.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.3046875	(*.f64 (log.f64 base) im)
accuracy	0.33822250976844204	(.f64 (.f64 (log.f64 base) im) (log.f64 im))
accuracy	1.807618107128984	(/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))
accuracy	5.055571290555962	(/.f64 (*.f64 re re) im)
accuracy	0.2578125	(*.f64 im (log.f64 im))
accuracy	0.3046875	(*.f64 (log.f64 base) im)
accuracy	0.6183733104084654	(/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im))
accuracy	0.8060150700787543	(/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))
accuracy	0.25390625	(/.f64 im (log.f64 base))
accuracy	0.2578125	(*.f64 (log.f64 im) im)
accuracy	0.27734375	(/.f64 re (log.f64 base))
accuracy	30.80791957853438	(/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))
accuracy	0.27734375	(/.f64 re (log.f64 base))
accuracy	3.585855184022548	(.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))
accuracy	5.848296477815994	(*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)
accuracy	61.767093314349076	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))
accuracy	0.15168227180825158	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))))
accuracy	0.3046875	(*.f64 (log.f64 base) im)
accuracy	0.3671875	(/.f64 (log.f64 im) (log.f64 base))
accuracy	0.6183733104084654	(/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im))

Samples

137.0ms

256×

valid

Compiler

Compiled 533 to 57 computations (89.3% saved)

Precisions

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

ival-div: 43.0ms (38.9% of total)

ival-mult: 39.0ms (35.3% of total)

ival-log: 13.0ms (11.8% of total)

ival-add: 9.0ms (8.1% of total)

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

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

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

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

exact: 0.0ms (0% of total)

series391.0ms (3.1%)

Memory

-32.9MiB live, 730.0MiB allocated

Counts

28 → 864

Calls

Call 1

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

Outputs
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2)) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2)) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2)) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2)) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ re (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ re (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ re (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ re (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (taylor inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ re (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ re (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ re (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ re (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log im) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log im) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log im) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log im) (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2)) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2)) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2)) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2)) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (* (pow im 2) (log im)) (log base)) (taylor 0 re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log im) 2)))) (/ (log base) (log im))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* 1/4 (/ (* (pow re 2) (log base)) (* (pow im 4) (pow (log im) 3)))) (* 1/2 (/ (log base) (* (pow im 2) (pow (log im) 2)))))) (/ (log base) (log im))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (- (* -1/8 (/ (* (pow re 2) (log base)) (* (pow im 6) (pow (log im) 4)))) (* -1/4 (/ (log base) (* (pow im 4) (pow (log im) 3)))))) (* 1/2 (/ (log base) (* (pow im 2) (pow (log im) 2)))))) (/ (log base) (log im))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor 0 re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (log base))) (taylor inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 2 (/ (* (pow im 2) (log base)) (pow re 2))) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))) (* 2 (* (pow im 2) (log base)))) (pow re 2)) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (- (+ (* 2 (* (pow im 2) (log base))) (* 8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4)))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2)))) (pow re 2)) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (- (+ (* -16 (/ (* (pow im 8) (* (log base) (pow (log im) 3))) (pow re 6))) (* 2 (* (pow im 2) (log base)))) (+ (* -8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))))) (pow re 2)) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (* (pow re 2) (log base)) im)) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (log base))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 2 (/ (* (pow im 2) (log base)) (pow re 2))) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* -4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))) (* 2 (* (pow im 2) (log base)))) (pow re 2)) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (- (+ (* 2 (* (pow im 2) (log base))) (* 8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4)))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2)))) (pow re 2)) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (- (+ (* -16 (/ (* (pow im 8) (* (log base) (pow (log im) 3))) (pow re 6))) (* 2 (* (pow im 2) (log base)))) (+ (* -8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))))) (pow re 2)) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (* (pow re 2) (log base)) im)) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor -inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor -inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor -inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ re (log base)) (taylor -inf re) (#s(alt (/.f64 re (log.f64 base)) (patch (/.f64 re (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (log base))) (taylor 0 im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (taylor 0 im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 2 (/ (* (pow im 2) (log base)) (pow re 2))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -4 (/ (* (pow im 2) (* (log base) (log im))) (pow re 4))) (* 2 (/ (log base) (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 2 (/ (log base) (pow re 2))) (* (pow im 2) (- (* 8 (/ (* (pow im 2) (* (log base) (pow (log im) 2))) (pow re 6))) (* 4 (/ (* (log base) (log im)) (pow re 4))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 2 (/ (log base) (pow re 2))) (* (pow im 2) (- (* (pow im 2) (- (* -16 (/ (* (pow im 2) (* (log base) (pow (log im) 3))) (pow re 8))) (* -8 (/ (* (log base) (pow (log im) 2)) (pow re 6))))) (* 4 (/ (* (log base) (log im)) (pow re 4))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (* (pow re 2) (log base)) im)) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor 0 im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (log im))) (taylor 0 im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log base))) (taylor inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3))))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/8 (/ (* (pow re 6) (log base)) (* (pow im 6) (pow (log (/ 1 im)) 4))))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (* (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (patch (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) (patch (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (patch (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) (patch (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (.f64 im im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) (patch (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 re (log.f64 base)))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (patch (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im))) (patch #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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (patch (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ re (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (+ (* -1/8 (/ (* (pow re 6) (log base)) (* (pow im 6) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 4)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) (patch (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (patch (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im)))))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 base)) (patch (/.f64 (log.f64 im) (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 (log.f64 im) im) (patch (.f64 (log.f64 im) im) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor -inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor -inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor -inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ im (log base)) (taylor -inf im) (#s(alt (/.f64 im (log.f64 base)) (patch (/.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) (patch (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 im (log.f64 im)) (patch (.f64 im (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (.f64 (log.f64 base) im) (log.f64 im)) (patch (.f64 (.f64 (log.f64 base) im) (log.f64 im)) #<representation:binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
108.0ms	re	@	0	((+ (* (/ 1/2 (* (log base) im)) (* (/ re im) re)) (/ (log im) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ 1/2 (* (log base) im)) (* (log base) im) (* (* (/ (/ 1/2 im) im) re) (/ re (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (/ (/ 1/2 im) im) re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (* im im)) (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (* (/ 1/2 (* (log base) im)) re) re) (* (/ 1/2 (* (log base) im)) re) (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im)))) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/ 1 (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (/ re (log base)) (* (log im) im) (/ im (log base)) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (* im (log im)) (/ (* re re) im) (* (* (log base) im) (log im)))
38.0ms	base	@	inf	((+ (* (/ 1/2 (* (log base) im)) (* (/ re im) re)) (/ (log im) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ 1/2 (* (log base) im)) (* (log base) im) (* (* (/ (/ 1/2 im) im) re) (/ re (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (/ (/ 1/2 im) im) re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (* im im)) (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (* (/ 1/2 (* (log base) im)) re) re) (* (/ 1/2 (* (log base) im)) re) (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im)))) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/ 1 (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (/ re (log base)) (* (log im) im) (/ im (log base)) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (* im (log im)) (/ (* re re) im) (* (* (log base) im) (log im)))
37.0ms	base	@	0	((+ (* (/ 1/2 (* (log base) im)) (* (/ re im) re)) (/ (log im) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ 1/2 (* (log base) im)) (* (log base) im) (* (* (/ (/ 1/2 im) im) re) (/ re (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (/ (/ 1/2 im) im) re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (* im im)) (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (* (/ 1/2 (* (log base) im)) re) re) (* (/ 1/2 (* (log base) im)) re) (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im)))) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/ 1 (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (/ re (log base)) (* (log im) im) (/ im (log base)) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (* im (log im)) (/ (* re re) im) (* (* (log base) im) (log im)))
34.0ms	base	@	-inf	((+ (* (/ 1/2 (* (log base) im)) (* (/ re im) re)) (/ (log im) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ 1/2 (* (log base) im)) (* (log base) im) (* (* (/ (/ 1/2 im) im) re) (/ re (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (/ (/ 1/2 im) im) re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (* im im)) (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (* (/ 1/2 (* (log base) im)) re) re) (* (/ 1/2 (* (log base) im)) re) (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im)))) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/ 1 (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (/ re (log base)) (* (log im) im) (/ im (log base)) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (* im (log im)) (/ (* re re) im) (* (* (log base) im) (log im)))
29.0ms	im	@	0	((+ (* (/ 1/2 (* (log base) im)) (* (/ re im) re)) (/ (log im) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ 1/2 (* (log base) im)) (* (log base) im) (* (* (/ (/ 1/2 im) im) re) (/ re (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (/ (/ 1/2 im) im) re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (* im im)) (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (* (/ 1/2 (* (log base) im)) re) re) (* (/ 1/2 (* (log base) im)) re) (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im)))) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/ 1 (/ (* (* (log base) im) (log base)) (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (/ re (log base)) (* (log im) im) (/ im (log base)) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (* im (log im)) (/ (* re re) im) (* (* (log base) im) (log im)))

simplify362.0ms (2.8%)

Memory

11.7MiB live, 336.2MiB allocated

Algorithm

1×	egg-herbie

Rules

8 048×	`lower-fma.f64`
8 048×	`lower-fma.f32`
6 046×	`lower-*.f64`
6 046×	`lower-*.f32`
4 458×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	418	14174
1	1209	13837
2	3912	13677
0	8822	13013

Stop Event

1×	iter limit
1×	node limit

Counts

864 → 864

Calls

Call 1

Inputs
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))))
(/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))))
(/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))))
(/ (* im (pow (log base) 2)) (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im)))) (* im (pow (log base) 2)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2))
(/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2))
(/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2))
(/ (+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base))))) (pow im 2))
(+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base)))))
(+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base)))))
(+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base)))))
(+ (* -1 (/ (* (pow im 2) (log im)) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (log (/ 1 base)))))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* -1/2 (/ re (* im (log (/ 1 base)))))
(* -1/2 (/ re (* im (log (/ 1 base)))))
(* -1/2 (/ re (* im (log (/ 1 base)))))
(* -1/2 (/ re (* im (log (/ 1 base)))))
(/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))))
(/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))))
(/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))))
(/ (* im (pow (log (/ 1 base)) 2)) (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))))
(+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))
(+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))
(+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))
(+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im)))
(/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2)))
(/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2)))
(/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 base)) 2)))
(/ (+ (* -1 (* im (* (log im) (log (/ 1 base))))) (* -1/2 (/ (* (pow re 2) (log (/ 1 base))) im))) (* im (pow (log (/ 1 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))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ re (log (/ 1 base))))
(* -1 (/ re (log (/ 1 base))))
(* -1 (/ re (log (/ 1 base))))
(* -1 (/ re (log (/ 1 base))))
(* -1 (/ im (log (/ 1 base))))
(* -1 (/ im (log (/ 1 base))))
(* -1 (/ im (log (/ 1 base))))
(* -1 (/ im (log (/ 1 base))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (* im (* (log im) (log (/ 1 base)))))
(* -1 (* im (* (log im) (log (/ 1 base)))))
(* -1 (* im (* (log im) (log (/ 1 base)))))
(* -1 (* im (* (log im) (log (/ 1 base)))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base)))))) (pow im 2))
(+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (+ (log -1) (* -1 (log (/ -1 base)))))) (/ (* (pow im 2) (log im)) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ re (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))))
(/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))))
(/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))))
(/ (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)) (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))))
(+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))
(+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))
(+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))
(+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))
(/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
(/ (+ (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 base))))) im)) (* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))) (* im (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ re (+ (log -1) (* -1 (log (/ -1 base)))))
(/ re (+ (log -1) (* -1 (log (/ -1 base)))))
(/ re (+ (log -1) (* -1 (log (/ -1 base)))))
(/ re (+ (log -1) (* -1 (log (/ -1 base)))))
(/ im (+ (log -1) (* -1 (log (/ -1 base)))))
(/ im (+ (log -1) (* -1 (log (/ -1 base)))))
(/ im (+ (log -1) (* -1 (log (/ -1 base)))))
(/ im (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(* im (* (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (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 base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (* (pow im 2) (log im)) (log base))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(* im (log im))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (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)))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(/ (log base) (log im))
(+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log im) 2)))) (/ (log base) (log im)))
(+ (* (pow re 2) (- (* 1/4 (/ (* (pow re 2) (log base)) (* (pow im 4) (pow (log im) 3)))) (* 1/2 (/ (log base) (* (pow im 2) (pow (log im) 2)))))) (/ (log base) (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1/8 (/ (* (pow re 2) (log base)) (* (pow im 6) (pow (log im) 4)))) (* -1/4 (/ (log base) (* (pow im 4) (pow (log im) 3)))))) (* 1/2 (/ (log base) (* (pow im 2) (pow (log im) 2)))))) (/ (log base) (log im)))
(* im (* (log base) (log im)))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(+ (* 1/2 (/ (* (pow re 2) (log base)) im)) (* im (* (log base) (log im))))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (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)))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(/ (log im) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) (log base)))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (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/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 2 (/ (* (pow im 2) (log base)) (pow re 2)))
(/ (+ (* -4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))) (* 2 (* (pow im 2) (log base)))) (pow re 2))
(/ (- (+ (* 2 (* (pow im 2) (log base))) (* 8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4)))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2)))) (pow re 2))
(/ (- (+ (* -16 (/ (* (pow im 8) (* (log base) (pow (log im) 3))) (pow re 6))) (* 2 (* (pow im 2) (log base)))) (+ (* -8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))))) (pow re 2))
(* 1/2 (/ (* (pow re 2) (log base)) im))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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 (log base))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) (log base)))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (log base))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (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/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 2 (/ (* (pow im 2) (log base)) (pow re 2)))
(/ (+ (* -4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))) (* 2 (* (pow im 2) (log base)))) (pow re 2))
(/ (- (+ (* 2 (* (pow im 2) (log base))) (* 8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4)))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2)))) (pow re 2))
(/ (- (+ (* -16 (/ (* (pow im 8) (* (log base) (pow (log im) 3))) (pow re 6))) (* 2 (* (pow im 2) (log base)))) (+ (* -8 (/ (* (pow im 6) (* (log base) (pow (log im) 2))) (pow re 4))) (* 4 (/ (* (pow im 4) (* (log base) (log im))) (pow re 2))))) (pow re 2))
(* 1/2 (/ (* (pow re 2) (log base)) im))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ (log base) im)) (/ (* im (* (log base) (log im))) (pow re 2))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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 (log base))
(/ re (log base))
(/ re (log base))
(/ re (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 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)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* 1/2 (/ (pow re 2) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base)))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (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)))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 2 (/ (* (pow im 2) (log base)) (pow re 2)))
(* (pow im 2) (+ (* -4 (/ (* (pow im 2) (* (log base) (log im))) (pow re 4))) (* 2 (/ (log base) (pow re 2)))))
(* (pow im 2) (+ (* 2 (/ (log base) (pow re 2))) (* (pow im 2) (- (* 8 (/ (* (pow im 2) (* (log base) (pow (log im) 2))) (pow re 6))) (* 4 (/ (* (log base) (log im)) (pow re 4)))))))
(* (pow im 2) (+ (* 2 (/ (log base) (pow re 2))) (* (pow im 2) (- (* (pow im 2) (- (* -16 (/ (* (pow im 2) (* (log base) (pow (log im) 3))) (pow re 8))) (* -8 (/ (* (log base) (pow (log im) 2)) (pow re 6))))) (* 4 (/ (* (log base) (log im)) (pow re 4)))))))
(* 1/2 (/ (* (pow re 2) (log base)) im))
(/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im)
(/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im)
(/ (+ (* 1/2 (* (pow re 2) (log base))) (* (pow im 2) (* (log base) (log im)))) im)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 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 im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(* im (log im))
(* im (log im))
(* im (log im))
(* im (log im))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* im (log im))
(* im (log im))
(* im (log im))
(* im (log im))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(* im (* (log base) (log im)))
(* -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/2 (/ (pow re 2) (* (pow im 2) (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 (/ (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/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (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)) (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/2 (/ (pow re 2) (* (pow im 2) (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 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(* -1 (/ (* (pow im 2) (log (/ 1 im))) (log base)))
(* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(* -1 (* im (log (/ 1 im))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* -1 (/ (log base) (log (/ 1 im))))
(+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3))))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/8 (/ (* (pow re 6) (log base)) (* (pow im 6) (pow (log (/ 1 im)) 4))))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(* -1 (* im (* (log base) (log (/ 1 im)))))
(* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))
(* im (+ (* -1 (* (log base) (log (/ 1 im)))) (* 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/2 (/ (pow re 2) (* (pow im 2) (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 (/ (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)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(* -1 (* im (log (/ 1 im))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* -1 (* im (* (log base) (log (/ 1 im)))))
(* -1 (* im (* (log base) (log (/ 1 im)))))
(* -1 (* im (* (log base) (log (/ 1 im)))))
(* -1 (* im (* (log base) (log (/ 1 im)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* -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/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (pow im 2)))
(* 1/2 (/ re (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)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))))
(* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))))
(* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))))
(* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ (pow re 2) (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(* 1/2 (/ re (* im (log base))))
(/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))
(+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))) (+ (* -1/8 (/ (* (pow re 6) (log base)) (* (pow im 6) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 4)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))) (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))))
(* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(* -1 (* im (+ (* -1 (* (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (* -1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* -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)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ im (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(* im (* (log base) (+ (log -1) (* -1 (log (/ -1 im))))))

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

rewrite251.0ms (2%)

Memory

18.4MiB live, 400.6MiB allocated

Rules

4 642×	`lower-fma.f32`
4 634×	`lower-fma.f64`
4 256×	`lower-/.f32`
4 232×	`lower-/.f64`
4 124×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	67	586
0	106	517
1	370	499
2	2747	499
0	8575	478

Stop Event

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

Counts

28 → 1 161

Calls

Call 1

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

Outputs
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal 1 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))
(.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) (pow.f64 im #s(literal -1 binary64)))
(.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (pow.f64 (/.f64 (-.f64 (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 im (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 (.f64 im (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 im (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (pow.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (pow.f64 (.f64 (neg.f64 im) (log.f64 base)) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(pow.f64 (exp.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))) #s(literal -1 binary64))
(pow.f64 (.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base)))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im)) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))) (neg.f64 (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))))
(/.f64 (neg.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (*.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im))))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im))))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64)))) (neg.f64 (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im)))
(/.f64 (neg.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))))
(/.f64 (neg.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (neg.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im) (log.f64 base))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))
(/.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64)) (.f64 im (log.f64 base)))
(/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64))) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base)) (.f64 im (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base))))))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base))))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im)))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64))) (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im)))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base))))
(/.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im))
(/.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)) im)
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))
(/.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)))
(/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 (neg.f64 im) (log.f64 base))))
(neg.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (neg.f64 (log.f64 im)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (pow.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) (pow.f64 im #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 re (log.f64 base)) (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (pow.f64 im #s(literal -1 binary64)) (.f64 (/.f64 re (log.f64 base)) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re re) (pow.f64 (.f64 im (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 re (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (/.f64 re im) re) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (*.f64 (/.f64 re im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(-.f64 (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))) (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im)))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))) (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))) (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 (neg.f64 im) (log.f64 base))) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (.f64 (neg.f64 im) (log.f64 base))))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (/.f64 (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))) (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(exp.f64 (.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))) #s(literal -1 binary64)))
(+.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (*.f64 (log.f64 im) im) (log.f64 base))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re))))
(+.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(+.f64 (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (pow.f64 im #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))
(.f64 #s(literal -1/2 binary64) (pow.f64 (.f64 (neg.f64 im) (log.f64 base)) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))
(pow.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal -1 binary64))
(pow.f64 (/.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (neg.f64 im))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) im)
(/.f64 #s(literal -1/2 binary64) (neg.f64 (neg.f64 (*.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (/.f64 #s(literal -1/2 binary64) im) (neg.f64 (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (/.f64 #s(literal 1/2 binary64) im) (log.f64 base))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))
(neg.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im (log.f64 base))))
(exp.f64 (.f64 (log.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64)))
(*.f64 im (log.f64 base))
(*.f64 (log.f64 base) im)
(.f64 (.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re)
(.f64 (/.f64 (.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im))
(.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (.f64 (/.f64 re im) re) im))
(.f64 (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(.f64 (.f64 (/.f64 re (log.f64 base)) re) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im))
(.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) im) re)
(.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (pow.f64 (.f64 (*.f64 im (log.f64 base)) im) #s(literal -1 binary64)))
(.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base))))
(.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (pow.f64 im #s(literal -1 binary64)))
(.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) (/.f64 re im))
(.f64 (/.f64 re (log.f64 base)) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re))
(.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)))
(.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (.f64 (/.f64 re (log.f64 base)) re))
(.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (pow.f64 im #s(literal -1 binary64)) (*.f64 (/.f64 re (log.f64 base)) re)))
(.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 (/.f64 re im) re) (log.f64 base)))
(.f64 (.f64 re re) (pow.f64 (.f64 im (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64)))
(.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))))
(.f64 re (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)))
(.f64 re (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 re (log.f64 base))))
(.f64 re (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) im))
(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (/.f64 re im) re))
(.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)))
(.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (/.f64 re im) re) (*.f64 im (log.f64 base))))
(.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (.f64 (/.f64 re im) re)))
(pow.f64 (/.f64 (.f64 (.f64 im (log.f64 base)) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 im (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 base) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) #s(literal -1 binary64))
(pow.f64 (.f64 (/.f64 (/.f64 im re) re) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64))
(pow.f64 (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) (/.f64 (/.f64 im re) re)) #s(literal -1 binary64))
(/.f64 (neg.f64 (/.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 base))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (.f64 (neg.f64 re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base))))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 (/.f64 re im) re))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) (.f64 (/.f64 re im) re))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 (neg.f64 re) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re))) (neg.f64 (/.f64 (log.f64 base) re)))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re (log.f64 base)))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 re (log.f64 base)) re))) (neg.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) im))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal -1/2 binary64))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1 binary64))) (neg.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (.f64 (/.f64 re (log.f64 base)) (.f64 (/.f64 #s(literal 1/2 binary64) im) re))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (neg.f64 re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #s(literal 1 binary64))) (neg.f64 (/.f64 (log.f64 base) re)))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #s(literal 1 binary64))) (neg.f64 (/.f64 (/.f64 im re) re)))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (.f64 (.f64 (neg.f64 re) re) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (neg.f64 (*.f64 (neg.f64 im) im)))
(/.f64 (neg.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal -1/2 binary64))) (neg.f64 (.f64 (neg.f64 im) (.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal 1 binary64))) (neg.f64 (.f64 (neg.f64 im) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (neg.f64 (.f64 (/.f64 (/.f64 im re) re) im)))
(/.f64 (neg.f64 (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (*.f64 (neg.f64 im) im))
(/.f64 (neg.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64))) (neg.f64 (.f64 im (.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 (neg.f64 re) re))) (neg.f64 (*.f64 (neg.f64 im) im)))
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) (.f64 (neg.f64 re) re))) (neg.f64 (.f64 (.f64 (neg.f64 im) (log.f64 base)) (neg.f64 im))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 re) re))) (neg.f64 (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) (neg.f64 im))))
(/.f64 (neg.f64 (.f64 (neg.f64 re) (.f64 (/.f64 #s(literal 1/2 binary64) im) re))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1/2 binary64) im) re))) (neg.f64 (*.f64 (/.f64 (log.f64 base) re) im)))
(/.f64 (neg.f64 (.f64 re (.f64 (/.f64 #s(literal 1/2 binary64) im) re))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (neg.f64 re))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 1 binary64))) (neg.f64 (*.f64 im (/.f64 (log.f64 base) re))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) #s(literal 1 binary64))) (neg.f64 (.f64 im (/.f64 (/.f64 im re) re))))
(/.f64 (neg.f64 (.f64 (/.f64 re im) re)) (neg.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (neg.f64 (/.f64 (log.f64 base) re)))
(/.f64 (neg.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal 1/2 binary64))) (neg.f64 (.f64 (neg.f64 im) (.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (.f64 (neg.f64 re) re))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (neg.f64 im))))
(/.f64 (neg.f64 (.f64 (.f64 re re) #s(literal 1 binary64))) (neg.f64 (.f64 im (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re))) (*.f64 (neg.f64 im) im))
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re))) (neg.f64 (.f64 (.f64 (neg.f64 im) (log.f64 base)) im)))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 re re))) (neg.f64 (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) im)))
(/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) (neg.f64 (/.f64 (/.f64 im re) re)))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (neg.f64 (neg.f64 (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (/.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 base)) im)
(/.f64 (.f64 (.f64 (neg.f64 re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) (neg.f64 im))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 (/.f64 re im) re)) im)
(/.f64 (.f64 #s(literal -1/2 binary64) (.f64 (/.f64 re im) re)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 (neg.f64 re) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (neg.f64 (log.f64 base)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (/.f64 (log.f64 base) re))
(/.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re (log.f64 base))) im)
(/.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re)) (neg.f64 im))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 re (log.f64 base)) re)) (/.f64 im (/.f64 #s(literal 1/2 binary64) im)))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re)) im)
(/.f64 (.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) im)
(/.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal -1/2 binary64)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1 binary64)) (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))
(/.f64 (.f64 (/.f64 re (log.f64 base)) (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) im)
(/.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (neg.f64 re)) (neg.f64 (log.f64 base)))
(/.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) #s(literal 1 binary64)) (/.f64 (log.f64 base) re))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #s(literal 1 binary64)) (/.f64 (/.f64 im re) re))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (*.f64 (neg.f64 im) im))
(/.f64 (neg.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (neg.f64 (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)) (neg.f64 im))
(/.f64 (neg.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (neg.f64 (log.f64 base)))
(/.f64 (.f64 (.f64 (neg.f64 re) re) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (*.f64 (neg.f64 im) im))
(/.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal -1/2 binary64)) (.f64 (neg.f64 im) (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal 1 binary64)) (.f64 (neg.f64 im) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (.f64 (.f64 (neg.f64 re) re) #s(literal 1/2 binary64)) (.f64 (neg.f64 im) (.f64 im (log.f64 base))))
(/.f64 (.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (.f64 (/.f64 (/.f64 im re) re) im))
(/.f64 (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (*.f64 im im))
(/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 im (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (.f64 (.f64 re re) #s(literal 1 binary64)) (.f64 im (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 (neg.f64 re) re)) (*.f64 (neg.f64 im) im))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re)) (*.f64 im im))
(/.f64 (.f64 #s(literal -1/2 binary64) (.f64 (neg.f64 re) re)) (.f64 (.f64 (neg.f64 im) (log.f64 base)) (neg.f64 im)))
(/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (.f64 (neg.f64 im) (log.f64 base)) im))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (neg.f64 re) re)) (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) (neg.f64 im)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 re re)) (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) im))
(/.f64 (.f64 #s(literal 1/2 binary64) (.f64 (neg.f64 re) re)) (.f64 (.f64 im (log.f64 base)) (neg.f64 im)))
(/.f64 (.f64 (neg.f64 re) (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (*.f64 (/.f64 (log.f64 base) re) im))
(/.f64 (.f64 re (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (*.f64 im (log.f64 base)))
(/.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (neg.f64 re)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 1 binary64)) (*.f64 im (/.f64 (log.f64 base) re)))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) #s(literal 1 binary64)) (.f64 im (/.f64 (/.f64 im re) re)))
(/.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 base))
(/.f64 #s(literal -1/2 binary64) (neg.f64 (.f64 (/.f64 (/.f64 im re) re) (.f64 im (log.f64 base)))))
(/.f64 #s(literal -1/2 binary64) (neg.f64 (.f64 (.f64 im (log.f64 base)) (/.f64 (/.f64 im re) re))))
(/.f64 #s(literal -1/2 binary64) (.f64 (/.f64 (/.f64 im re) re) (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (neg.f64 im) (log.f64 base)) (/.f64 (/.f64 im re) re)))
(/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 (.f64 im (log.f64 base)) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 base) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (.f64 (/.f64 (/.f64 im re) re) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) (/.f64 (/.f64 im re) re))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 im (log.f64 base)) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 im (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 im re) re) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)) (/.f64 (/.f64 im re) re)))
(/.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 im (log.f64 base)))
(/.f64 (.f64 (/.f64 re im) re) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) im)
(/.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (*.f64 im im))
(/.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 (log.f64 base) re))
(/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base))) (/.f64 (/.f64 im re) re))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (.f64 (/.f64 (/.f64 im re) re) (.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (.f64 (.f64 (neg.f64 im) (log.f64 base)) (/.f64 (/.f64 im re) re))))
(/.f64 #s(literal 1/2 binary64) (.f64 (/.f64 (/.f64 im re) re) (.f64 im (log.f64 base))))
(/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im (log.f64 base)) (/.f64 (/.f64 im re) re)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))))
#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (pow.f64 im #s(literal -1 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 re im))
(*.f64 re (/.f64 (/.f64 #s(literal 1/2 binary64) im) im))
(pow.f64 (.f64 (.f64 im #s(literal 2 binary64)) (/.f64 im re)) #s(literal -1 binary64))
(pow.f64 (/.f64 im (*.f64 (/.f64 #s(literal 1/2 binary64) im) re)) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) im) re)) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (*.f64 re (/.f64 #s(literal -1/2 binary64) im))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) re)) (neg.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) im))))
(/.f64 (neg.f64 (*.f64 re #s(literal 1 binary64))) (neg.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) im))))
(/.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) im) re) (neg.f64 im))
(/.f64 (*.f64 re (/.f64 #s(literal -1/2 binary64) im)) (neg.f64 im))
(/.f64 (*.f64 re #s(literal 1 binary64)) (/.f64 im (/.f64 #s(literal 1/2 binary64) im)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (neg.f64 im))
(/.f64 (neg.f64 (.f64 re #s(literal 1/2 binary64))) (.f64 (neg.f64 im) im))
(/.f64 (*.f64 #s(literal 1 binary64) re) (/.f64 im (/.f64 #s(literal 1/2 binary64) im)))
(/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) im)
(/.f64 (neg.f64 re) (neg.f64 (/.f64 im (/.f64 #s(literal 1/2 binary64) im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 (/.f64 #s(literal 1/2 binary64) im) re))))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 (/.f64 #s(literal 1/2 binary64) im) re)))
(/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im))
(/.f64 re (/.f64 im (/.f64 #s(literal 1/2 binary64) im)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (pow.f64 im #s(literal -2 binary64)) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)))))
#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (pow.f64 im #s(literal -2 binary64)) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))))
(.f64 (pow.f64 (/.f64 (.f64 im im) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)))
(.f64 (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im) (pow.f64 im #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im))
(.f64 (pow.f64 im #s(literal -2 binary64)) (pow.f64 (pow.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -2 binary64)) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)))
(.f64 (neg.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) (pow.f64 (*.f64 (neg.f64 im) im) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (.f64 (pow.f64 im #s(literal -2 binary64)) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))))
(.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (pow.f64 im #s(literal -2 binary64)))
(pow.f64 (/.f64 im (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) #s(literal -1 binary64))
(/.f64 (neg.f64 (.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 im #s(literal -2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (*.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (pow.f64 im #s(literal -2 binary64)))) (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) #s(literal 1 binary64))) (*.f64 (neg.f64 im) im))
(/.f64 (neg.f64 (neg.f64 (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))))) (neg.f64 (neg.f64 (.f64 (neg.f64 im) im))))
(/.f64 (neg.f64 (.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) (*.f64 im im))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) (.f64 im im))))
(/.f64 (.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 im #s(literal -2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (*.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))
(/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (pow.f64 im #s(literal -2 binary64))) (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) #s(literal 1 binary64)) (*.f64 im im))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im)) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (neg.f64 im) im)))
(/.f64 (neg.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 im im) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 im im) (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))))))
(/.f64 (.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) (*.f64 im im)))
(/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) (.f64 im im)))
(/.f64 (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im) im)
(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 im im) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))))
(/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (.f64 (.f64 im im) (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) (.f64 (neg.f64 im) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))))))
(/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))))
(/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (.f64 im im))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))) (.f64 im im)))
(neg.f64 (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (.f64 (neg.f64 im) im)))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)) (.f64 (.f64 im im) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))) (/.f64 (.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (.f64 (.f64 im im) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 (neg.f64 im) im)) (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (*.f64 (neg.f64 im) im)))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))) (.f64 im im)) (/.f64 (/.f64 (.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))) (.f64 im im)))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 im im) (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)))
(.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (*.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (pow.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)))
(pow.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (log.f64 im) im) im) (log.f64 base) (.f64 (log.f64 base) (.f64 (*.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (log.f64 base) (.f64 (*.f64 (log.f64 im) im) im)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)))
(/.f64 (neg.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (*.f64 re #s(literal 1/2 binary64)) re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (.f64 (.f64 (log.f64 im) im) im) (log.f64 base) (.f64 (log.f64 base) (.f64 (*.f64 re #s(literal 1/2 binary64)) re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (log.f64 base) (.f64 (*.f64 (log.f64 im) im) im))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)))
(/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (*.f64 re #s(literal 1/2 binary64)) re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base)) (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base)) (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64))) (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal -3 binary64)) (pow.f64 (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 3 binary64)))))
(fma.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 (.f64 (/.f64 im (log.f64 base)) (log.f64 im)) im (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 (.f64 (.f64 (log.f64 im) im) im) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 1/2 binary64) (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 re (log.f64 base)) (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 (/.f64 im (log.f64 base)) (.f64 (log.f64 im) im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 (/.f64 re (log.f64 base)) (.f64 re #s(literal 1/2 binary64)) (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 (log.f64 im) (.f64 (/.f64 im (log.f64 base)) im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 re (.f64 #s(literal 1/2 binary64) (/.f64 re (log.f64 base))) (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 re (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 re #s(literal 1/2 binary64))) (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(fma.f64 im (.f64 (log.f64 im) (/.f64 im (log.f64 base))) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 im (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (log.f64 im) im)) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(fma.f64 #s(literal 1/2 binary64) (.f64 (/.f64 re (log.f64 base)) re) (.f64 (*.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(-.f64 (/.f64 (.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (log.f64 im) im) im)) (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))) (/.f64 (.f64 (pow.f64 (.f64 (/.f64 re (log.f64 base)) re) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (/.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) im) (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (log.f64 base))))
(+.f64 (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)) (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re))
(+.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im)))
(.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(pow.f64 (/.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (log.f64 im) im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 im) im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))))
(fma.f64 (.f64 (log.f64 base) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) re (.f64 (log.f64 im) im))
(fma.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 re re) (.f64 (log.f64 im) im))
(fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))
(fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (log.f64 base) (.f64 (log.f64 im) im))
(fma.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 re (log.f64 base)) (.f64 (log.f64 im) im))
(fma.f64 (log.f64 im) im (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))))
(fma.f64 re (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (log.f64 base)) (.f64 (log.f64 im) im))
(fma.f64 re (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 re (log.f64 base))) (.f64 (log.f64 im) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (.f64 re re) (log.f64 base)) (.f64 (log.f64 im) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 re (.f64 re (log.f64 base))) (.f64 (log.f64 im) im))
(fma.f64 im (log.f64 im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))))
(fma.f64 (log.f64 base) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (.f64 (log.f64 im) im))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (.f64 (log.f64 im) im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))))) (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (-.f64 (.f64 (log.f64 im) im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base))))))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im))))
(+.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im))
(+.f64 (.f64 (log.f64 im) im) (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (*.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))) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)
(.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base))))
(.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))))
(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 re re))
(.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (.f64 re re)))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 re re))) (neg.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re)) im)
(/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 re re)) (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (*.f64 im (log.f64 base)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 re im))
(.f64 (.f64 re #s(literal 1/2 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)))
(*.f64 (/.f64 re (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 re (log.f64 base)))
(*.f64 (/.f64 re im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))
(.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))
(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) re)
(.f64 #s(literal 1/2 binary64) (/.f64 re (.f64 im (log.f64 base))))
(.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)) re))
(pow.f64 (.f64 (/.f64 (log.f64 base) re) (.f64 im #s(literal 2 binary64))) #s(literal -1 binary64))
(pow.f64 (.f64 (.f64 im #s(literal 2 binary64)) (/.f64 (log.f64 base) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (log.f64 base))) (neg.f64 im))
(/.f64 (neg.f64 (*.f64 re (/.f64 #s(literal 1/2 binary64) (log.f64 base)))) (neg.f64 im))
(/.f64 (neg.f64 (.f64 re #s(literal -1/2 binary64))) (neg.f64 (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (.f64 re #s(literal 1/2 binary64)))) (neg.f64 (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) re)) (neg.f64 im))
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) re)) (neg.f64 (.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) re)) (neg.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 re #s(literal 1 binary64))) (neg.f64 (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (log.f64 base)) im)
(/.f64 (*.f64 re (/.f64 #s(literal 1/2 binary64) (log.f64 base))) im)
(/.f64 (.f64 re #s(literal -1/2 binary64)) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 re #s(literal 1 binary64)) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (.f64 re #s(literal 1/2 binary64))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) re) im)
(/.f64 (.f64 #s(literal -1/2 binary64) re) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (.f64 #s(literal 1 binary64) re) (.f64 (*.f64 im (log.f64 base)) #s(literal 2 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (log.f64 base))
(/.f64 (neg.f64 re) (neg.f64 (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 re #s(literal 1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 im (log.f64 base)) (.f64 re #s(literal 1/2 binary64))))
(/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im (log.f64 base)))
(/.f64 re (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64)))
(.f64 (pow.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) #s(literal -1 binary64)) (pow.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) #s(literal -1 binary64)) (pow.f64 (pow.f64 (/.f64 (-.f64 (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) #s(literal -1 binary64)) (pow.f64 (pow.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) #s(literal -1 binary64)) (pow.f64 (pow.f64 (.f64 (neg.f64 im) (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)) (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (/.f64 (.f64 im (log.f64 base)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))
(.f64 (/.f64 (.f64 im (log.f64 base)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))
(.f64 (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (*.f64 im (log.f64 base)))
(.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64)) (pow.f64 (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (pow.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (pow.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)))
(.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal 1 binary64))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (/.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)) #s(literal 1 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (.f64 im (log.f64 base)) (/.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal 1 binary64)))
(.f64 (.f64 im (log.f64 base)) (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(.f64 im (.f64 (log.f64 base) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))))
(.f64 im (/.f64 (log.f64 base) (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))))
(.f64 (log.f64 base) (/.f64 im (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))))
(.f64 (log.f64 base) (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))))
(.f64 (log.f64 base) (.f64 im (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))))
(pow.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal 1 binary64))
(pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64))
(/.f64 (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal 1 binary64))) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))) (neg.f64 (neg.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal 1 binary64)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))
(/.f64 (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))) (neg.f64 (.f64 #s(literal 1 binary64) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))) (neg.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 (neg.f64 im) (log.f64 base))) (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (.f64 #s(literal 1 binary64) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64))
(/.f64 (.f64 (neg.f64 im) (log.f64 base)) (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(/.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal 1 binary64))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))
(/.f64 (.f64 im (log.f64 base)) (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 #s(literal 1 binary64) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 #s(literal 1 binary64) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))) (/.f64 (.f64 im (log.f64 base)) (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (neg.f64 (.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))) #s(literal -1 binary64))))
(exp.f64 (.f64 (.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))) (pow.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))
(.f64 (log.f64 base) (fma.f64 (log.f64 im) im (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))
(pow.f64 (/.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (neg.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (*.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))))
(fma.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (.f64 (log.f64 im) (log.f64 base)) im (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 (.f64 (log.f64 base) (log.f64 im)) im (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (.f64 (/.f64 re im) re) (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (.f64 (log.f64 im) im) (log.f64 base) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal -1 binary64)) (.f64 (log.f64 base) #s(literal 1/2 binary64))) (.f64 (*.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (log.f64 im) (.f64 im (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 (/.f64 re im) (.f64 re (.f64 (log.f64 base) #s(literal 1/2 binary64))) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 re (.f64 (/.f64 re im) (.f64 (log.f64 base) #s(literal 1/2 binary64))) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (.f64 im (log.f64 base)) (log.f64 im) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 im (.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 (log.f64 base) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(fma.f64 (log.f64 base) (.f64 (log.f64 im) im) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 (/.f64 re im) re) (log.f64 base)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))) (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(+.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (*.f64 (log.f64 im) im) (log.f64 base)))
(+.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)))
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal 1 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))
(.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) (pow.f64 im #s(literal -1 binary64)))
(.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (pow.f64 (/.f64 (-.f64 (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 im (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 (.f64 im (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 im (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (pow.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (pow.f64 (.f64 (neg.f64 im) (log.f64 base)) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(pow.f64 (exp.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))) #s(literal -1 binary64))
(pow.f64 (.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base)))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im)) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))) (neg.f64 (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))))
(/.f64 (neg.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (*.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im))))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im))))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64)))) (neg.f64 (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im)))
(/.f64 (neg.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))))
(/.f64 (neg.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (neg.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im) (log.f64 base))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))
(/.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64)) (.f64 im (log.f64 base)))
(/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64))) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base)) (.f64 im (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base))))))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base))))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im)))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64))) (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im)))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base))))
(/.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im))
(/.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)) im)
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))
(/.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)))
(/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 (neg.f64 im) (log.f64 base))))
(neg.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (neg.f64 (log.f64 im)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (pow.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) (pow.f64 im #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 re (log.f64 base)) (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (pow.f64 im #s(literal -1 binary64)) (.f64 (/.f64 re (log.f64 base)) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re re) (pow.f64 (.f64 im (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 re (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (/.f64 re im) re) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (*.f64 (/.f64 re im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(-.f64 (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))) (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im)))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))) (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))) (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 (neg.f64 im) (log.f64 base))) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (.f64 (neg.f64 im) (log.f64 base))))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (/.f64 (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))) (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(exp.f64 (.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))) #s(literal -1 binary64)))
(+.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (*.f64 (log.f64 im) im) (log.f64 base))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re))))
(+.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(+.f64 (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 base)))
(*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(pow.f64 (/.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (log.f64 im)))) (neg.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 (neg.f64 (*.f64 (log.f64 im) #s(literal 1 binary64))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (log.f64 im))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) (log.f64 base))
(/.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 base))
(neg.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)))
(neg.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 base))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (log.f64 base))) (/.f64 (log.f64 im) (neg.f64 (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) re)
(*.f64 (neg.f64 re) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 re (log.f64 base)))
(*.f64 re (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(pow.f64 (/.f64 (/.f64 (log.f64 base) re) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 base) re) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 re #s(literal 1 binary64))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 re))) (neg.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 (*.f64 re #s(literal 1 binary64)) (log.f64 base))
(/.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 re) (neg.f64 (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (log.f64 base) re) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 base) re)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 base) re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 base) re) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) re))
(/.f64 re (log.f64 base))
(neg.f64 (/.f64 (neg.f64 re) (log.f64 base)))
(neg.f64 (/.f64 re (neg.f64 (log.f64 base))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (log.f64 base))) (/.f64 re (neg.f64 (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) re)) #s(literal -1 binary64)))
(*.f64 (log.f64 im) im)
(*.f64 im (log.f64 im))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) im)
(*.f64 (neg.f64 im) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 im (log.f64 base)))
(*.f64 im (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(pow.f64 (/.f64 (/.f64 (log.f64 base) im) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 base) im) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 im #s(literal 1 binary64))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 im))) (neg.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(/.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (*.f64 im #s(literal 1 binary64)) (log.f64 base))
(/.f64 (neg.f64 im) (neg.f64 (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (log.f64 base) im) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 base) im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 base) im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 base) im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) im))
(/.f64 im (log.f64 base))
(neg.f64 (/.f64 (neg.f64 im) (log.f64 base)))
(neg.f64 (/.f64 im (neg.f64 (log.f64 base))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (log.f64 base))) (/.f64 im (neg.f64 (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) im)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 im (log.f64 base)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (pow.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) #s(literal -1 binary64)) (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))
(.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal 1 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal -1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))
(.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) (pow.f64 im #s(literal -1 binary64)))
(.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (pow.f64 (/.f64 (-.f64 (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 im (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 (.f64 im (log.f64 base)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))) #s(literal -1 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (.f64 im (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im))))) #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (pow.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (pow.f64 (.f64 (neg.f64 im) (log.f64 base)) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))
(.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))
(.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(pow.f64 (exp.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))) #s(literal -1 binary64))
(pow.f64 (.f64 (pow.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))) (.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) #s(literal 3 binary64)) (pow.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) #s(literal 3 binary64))) (fma.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (-.f64 (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))) (.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)))))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base)))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im)) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(/.f64 (neg.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base))) (.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))) (neg.f64 (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))))
(/.f64 (neg.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (*.f64 (neg.f64 im) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im))))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im)))) (neg.f64 (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im))))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64)))) (neg.f64 (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))) (neg.f64 (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re)))) (neg.f64 (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im)))
(/.f64 (neg.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re)))) (neg.f64 (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im))))
(/.f64 (neg.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64))))
(/.f64 (neg.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (neg.f64 (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (log.f64 base))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) im) (log.f64 base))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64))) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))
(/.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))
(/.f64 (.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) #s(literal 1 binary64)) (.f64 im (log.f64 base)))
(/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64))) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))
(/.f64 (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (log.f64 base)) (.f64 im (log.f64 base)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))) (neg.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))))) (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base)))))))
(/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)))) (neg.f64 (*.f64 (neg.f64 im) (log.f64 base))))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64)))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (.f64 im (log.f64 base))))))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base))))
(/.f64 (.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (neg.f64 (log.f64 base)) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 im)))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (neg.f64 (log.f64 base))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal 1 binary64))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (log.f64 base) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 im))) (.f64 (.f64 (.f64 im (log.f64 base)) im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) (neg.f64 (log.f64 im)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) #s(literal 1 binary64))) (.f64 (.f64 im (log.f64 base)) (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (neg.f64 (log.f64 base)) (.f64 im (neg.f64 (log.f64 im)))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im))))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (.f64 im (log.f64 base)) (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) im (.f64 (neg.f64 (log.f64 base)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 (.f64 im (log.f64 base)) im) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (fma.f64 #s(literal 1 binary64) (.f64 im (log.f64 base)) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))) (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 im (log.f64 base))))
(/.f64 (fma.f64 #s(literal 1 binary64) im (.f64 (/.f64 (log.f64 base) (log.f64 im)) (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) re))) (*.f64 (/.f64 (log.f64 base) (log.f64 im)) im))
(/.f64 (fma.f64 (log.f64 im) (.f64 (.f64 im (log.f64 base)) im) (.f64 (log.f64 base) (.f64 (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (log.f64 base) (.f64 (.f64 im (log.f64 base)) im)))
(/.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (pow.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) #s(literal -1 binary64)))
(/.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)) im)
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im)))))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)))
(/.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 base) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)) (pow.f64 (.f64 (log.f64 im) im) #s(literal 3 binary64))) (.f64 (.f64 im (log.f64 base)) (-.f64 (hypot.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)) (.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))))
(/.f64 (fma.f64 (pow.f64 (.f64 (log.f64 base) (.f64 (/.f64 re im) re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 3 binary64))) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (-.f64 (hypot.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (log.f64 im)) (*.f64 im (log.f64 base))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (+.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (log.f64 im)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))) (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))))
(/.f64 (neg.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im)))) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 (neg.f64 im) (log.f64 base)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base)) (-.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/4 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (.f64 im (log.f64 base)) im)) #s(literal 2 binary64)) (.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal -1 binary64)))
(/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))
(/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 im (log.f64 base)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(neg.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (*.f64 (neg.f64 im) (log.f64 base))))
(neg.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))) #s(literal -1 binary64)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))))
(fma.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) re (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (neg.f64 (log.f64 im)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (pow.f64 (.f64 (.f64 im (log.f64 base)) im) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(fma.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (pow.f64 (*.f64 im (log.f64 base)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) (pow.f64 im #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 re (log.f64 base)) (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) (/.f64 re (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (*.f64 (/.f64 re (log.f64 base)) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (pow.f64 im #s(literal -1 binary64)) (.f64 (/.f64 re (log.f64 base)) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (.f64 re re) (pow.f64 (.f64 im (.f64 (.f64 im (log.f64 base)) #s(literal 2 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(fma.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (*.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 re (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 re (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) im) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im (log.f64 base)) im)) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (/.f64 re im) re) (.f64 im (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) (*.f64 (/.f64 re im) re)) (/.f64 (log.f64 im) (log.f64 base)))
(-.f64 (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))) (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (log.f64 im) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re)) (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im)))) (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (.f64 (.f64 im (log.f64 base)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (*.f64 (log.f64 im) im)))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im))))) (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (*.f64 (log.f64 im) im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))) (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im))))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 (neg.f64 im) (log.f64 base))) (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (.f64 (log.f64 im) im)) (.f64 (neg.f64 im) (log.f64 base))))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)) (/.f64 (/.f64 (pow.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) #s(literal 2 binary64)) (.f64 (log.f64 base) (-.f64 (.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (.f64 (log.f64 im) im)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
(-.f64 (/.f64 (/.f64 (pow.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (.f64 im (log.f64 base))) (/.f64 (/.f64 (pow.f64 (.f64 (log.f64 im) im) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))))) (.f64 (log.f64 im) im))) (*.f64 im (log.f64 base))))
(-.f64 (/.f64 (pow.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))) (/.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (-.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 im)) (log.f64 base))))
(exp.f64 (.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))))) #s(literal -1 binary64)))
(+.f64 (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (.f64 (.f64 (log.f64 im) im) (log.f64 base)) (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))) (.f64 (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (*.f64 (log.f64 im) im) (log.f64 base))))
(+.f64 (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 im) im) (log.f64 base))) (.f64 (pow.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im) #s(literal -1 binary64)) (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re))))
(+.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))) (/.f64 (log.f64 im) (log.f64 base)))
(+.f64 (/.f64 (log.f64 im) (log.f64 base)) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base))))
(*.f64 (log.f64 im) im)
(*.f64 im (log.f64 im))
(*.f64 (pow.f64 im #s(literal -1 binary64)) (pow.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 im #s(literal -1 binary64)) (.f64 re re))
(.f64 (.f64 (neg.f64 re) re) (pow.f64 (neg.f64 im) #s(literal -1 binary64)))
(.f64 #s(literal 1 binary64) (.f64 (/.f64 re im) re))
(.f64 (.f64 re re) (pow.f64 im #s(literal -1 binary64)))
(*.f64 (/.f64 re im) re)
(*.f64 re (/.f64 re im))
(pow.f64 (/.f64 (/.f64 (/.f64 im re) re) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 im re) re) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 (*.f64 (neg.f64 re) re))) (neg.f64 (neg.f64 (neg.f64 im))))
(/.f64 (neg.f64 (.f64 (.f64 re re) #s(literal 1 binary64))) (neg.f64 im))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) re)) (neg.f64 (/.f64 im re)))
(/.f64 (neg.f64 (*.f64 re #s(literal 1 binary64))) (neg.f64 (/.f64 im re)))
(/.f64 (*.f64 re #s(literal 1 binary64)) (/.f64 im re))
(/.f64 (neg.f64 (*.f64 (neg.f64 re) re)) (neg.f64 (neg.f64 im)))
(/.f64 (.f64 (.f64 re re) #s(literal 1 binary64)) im)
(/.f64 (*.f64 #s(literal 1 binary64) re) (/.f64 im re))
(/.f64 (*.f64 (neg.f64 re) re) (neg.f64 im))
(/.f64 (neg.f64 re) (neg.f64 (/.f64 im re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (/.f64 im re) re) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 im re) re)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (/.f64 im re) re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (/.f64 im re) re) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im re) re))
(/.f64 (*.f64 re re) im)
(/.f64 re (/.f64 im re))
(neg.f64 (/.f64 (*.f64 (neg.f64 re) re) im))
(neg.f64 (/.f64 (*.f64 re re) (neg.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 im)) (/.f64 (*.f64 re re) (neg.f64 im)))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 im re) re)) #s(literal -1 binary64)))
(.f64 (.f64 (log.f64 im) (log.f64 base)) im)
(.f64 (.f64 (log.f64 base) (log.f64 im)) im)
(.f64 (.f64 (log.f64 im) im) (log.f64 base))
(.f64 (log.f64 im) (.f64 im (log.f64 base)))
(.f64 (.f64 im (log.f64 base)) (log.f64 im))
(.f64 im (.f64 (log.f64 base) (log.f64 im)))
(.f64 (log.f64 base) (.f64 (log.f64 im) im))

eval398.0ms (3.1%)

Memory: 46.5MiB live, 683.3MiB allocated
Compiler: Compiled 61 692 to 4 185 computations (93.2% saved)

prune226.0ms (1.8%)

Memory

-46.9MiB live, 499.7MiB allocated

Pruning

54 alts after pruning (52 fresh and 2 done)

	Pruned	Kept	Total
New	2 187	40	2 227
Fresh	7	12	19
Picked	4	1	5
Done	0	1	1
Total	2 198	54	2 252

Accuracy

99.8%

Counts

2 252 → 54

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) re) (/.f64 re im))))
✓	99.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) (.f64 (/.f64 re im) re) (/.f64 (log.f64 im) (log.f64 base))))
	48.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (pow.f64 (pow.f64 (fma.f64 (/.f64 (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (/.f64 (log.f64 im) (log.f64 base))) #s(literal 1/2 binary64)) #s(literal 2 binary64)))
	93.9%	#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) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (.f64 (.f64 (log.f64 base) im) (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 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
	96.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (.f64 (log.f64 im) im))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) im)))
	47.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
	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) (/.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
	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) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	47.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) (exp.f64 (log.f64 (log.f64 base)))))
▶	94.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)))
	52.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) im)) (.f64 (log.f64 base) im)))
	35.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (.f64 (fma.f64 (/.f64 (log.f64 im) re) (/.f64 im re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re))) (*.f64 (log.f64 base) im)))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))) (*.f64 (log.f64 base) im)))
	98.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (.f64 (log.f64 im) im)) (.f64 (log.f64 base) im)))
	96.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) (fma.f64 (.f64 (log.f64 im) (log.f64 base)) im (.f64 (.f64 (log.f64 base) #s(literal 1/2 binary64)) (.f64 (/.f64 re im) re))))))
	51.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) #s(approx (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (/.f64 (.f64 (log.f64 base) (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64)))) im)))))
	96.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 base) im) (log.f64 base)) #s(approx (+ (* (* (/ (* re re) im) 1/2) (log base)) (* (* (log base) im) (log im))) (.f64 (.f64 (log.f64 im) im) (log.f64 base))))))
▶	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
	98.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -1 binary64)))))
	96.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))))
	98.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (/.f64 im (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im))))))
	98.1%	#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 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (log.f64 base) (.f64 im (log.f64 im))) (pow.f64 (.f64 (log.f64 base) im) #s(literal -1 binary64))))
	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im)))
▶	48.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))))
	94.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (/.f64 (/.f64 (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) im) (log.f64 base))))
	49.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 re (log.f64 base))) (/.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) im)) (.f64 re re))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) im) re) re)))
	50.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (/.f64 re (log.f64 base)) (.f64 re #s(literal 1/2 binary64)) (.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im))) (.f64 im im))))
	50.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) (log.f64 im)) im (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 re (log.f64 base)) (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) im)))
▶	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re)) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) #s(literal 1 binary64)) (.f64 im (/.f64 (/.f64 im re) re)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re)) im)))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 base))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) im)))
▶	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 re (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (*.f64 im (log.f64 base)))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(approx (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) re) re)) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))))
	52.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) im) (log.f64 im) (.f64 (*.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) im)))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1 binary64) (/.f64 im (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 re im) re) (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) im) (/.f64 re (log.f64 base)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) im) re)))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (/.f64 re (log.f64 base)))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (/.f64 re im) re))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re)))

Compiler

Compiled 1 816 to 1 430 computations (21.3% saved)

simplify108.0ms (0.8%)

Memory

36.9MiB live, 110.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 (/.f64 (log.f64 base) (log.f64 im)))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))))
cost-diff	192	(*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))
cost-diff	12928	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))
cost-diff	0	(fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))
cost-diff	0	#s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)))
cost-diff	0	(/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)))
cost-diff	0	(/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))
cost-diff	0	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))))
cost-diff	128	(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))
cost-diff	0	(*.f64 re #s(literal 1/2 binary64))
cost-diff	0	(.f64 (.f64 re #s(literal 1/2 binary64)) re)
cost-diff	0	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))))
cost-diff	0	(log.f64 base)
cost-diff	0	(/.f64 (log.f64 base) (log.f64 im))
cost-diff	0	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
cost-diff	704	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))

Rules

3 014×	`lower-fma.f32`
3 012×	`lower-fma.f64`
2 774×	`lower-*.f32`
2 754×	`lower-*.f64`
1 400×	`times-frac`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	65	553
0	94	513
1	169	502
2	366	493
3	1292	452
4	3900	442
5	6266	442
6	7484	442
0	8017	418

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

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

localize222.0ms (1.7%)

Memory

-28.2MiB live, 246.4MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.09441376953688403	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))
accuracy	0.16015625	(/.f64 (log.f64 base) (log.f64 im))
accuracy	0.17861107979522167	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))))
accuracy	0.34302942980949325	(log.f64 (/.f64 (log.f64 base) (log.f64 im)))
accuracy	0.14453125	(*.f64 (log.f64 base) im)
accuracy	0.150722509768442	(/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))
accuracy	0.15168227180825158	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)))
accuracy	2.703366404513128	(/.f64 (*.f64 re re) im)
accuracy	0.15168227180825158	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))))
accuracy	1.8445527454801618	(/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))
accuracy	2.6710089723584263	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re))
accuracy	30.18915922866644	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))
accuracy	0.14453125	(*.f64 im (log.f64 base))
accuracy	0.15168227180825158	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))))
accuracy	6.7318302718619565	(/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))
accuracy	30.18915922866644	#s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))
accuracy	0	(log.f64 base)
accuracy	0.1328125	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))
accuracy	0.16015625	(/.f64 (log.f64 base) (log.f64 im))
accuracy	0.17861107979522167	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))

Samples

101.0ms	125×	0	valid
52.0ms	131×	0	invalid

Compiler

Compiled 394 to 53 computations (86.5% saved)

Precisions

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

ival-atan2: 31.0ms (24% of total)

ival-mult: 27.0ms (20.9% of total)

ival-div: 24.0ms (18.6% of total)

ival-log: 17.0ms (13.2% of total)

ival-neg: 14.0ms (10.8% of total)

ival-add: 8.0ms (6.2% of total)

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

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

exact: 1.0ms (0.8% of total)

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

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

series446.0ms (3.5%)

Memory

10.6MiB live, 590.8MiB allocated

Counts

25 → 708

Calls

Call 1

Inputs
#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())
#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())
#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())
#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())
#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())
#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())
#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())
#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())
#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())
#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())
#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())
#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())
#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())
#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())
#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())
#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())
#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())
#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())
#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())
#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())
#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())
#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())
#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())
#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())
#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())

Outputs
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (log base) (taylor 0 base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base))) (taylor 0 base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base)) (taylor 0 base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 base)) (log im))) (taylor inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 base)) (log im))) (taylor inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 base)) (log im))) (taylor inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 base)) (log im))) (taylor inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 base))) (taylor inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))) (taylor inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ -1/2 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log (/ 1 base)))) (taylor inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log (/ 1 base)) (log im))))) (taylor inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log (/ 1 base)) (log im))))) (taylor inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log (/ 1 base)) (log im))))) (taylor inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log (/ 1 base)) (log im))))) (taylor inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base)))) (taylor inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log (/ 1 base)) (log im)))) (taylor inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log (/ 1 base)) (log im)))) (taylor inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log (/ 1 base)) (log im)))) (taylor inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log (/ 1 base)) (log im)))) (taylor inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))) (taylor inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* im (log (/ 1 base))))) (taylor inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 base)))) (taylor inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)) (taylor -inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)) (taylor -inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)) (taylor -inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)) (taylor -inf base) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 base)))) (taylor -inf base) (#s(alt (log.f64 base) (patch (log.f64 base) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base)))))) (taylor -inf base) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor -inf base) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))) (taylor -inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))) (taylor -inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))) (taylor -inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))) (taylor -inf base) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))) (taylor -inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))) (taylor -inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))) (taylor -inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))) (taylor -inf base) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base))))))) (taylor -inf base) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 base))))) (taylor -inf base) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor 0 re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor 0 re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor 0 re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor 0 re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* im (log im)) (taylor 0 re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log base))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor -inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor -inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor -inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (pow re 2)) (taylor -inf re) (#s(alt (.f64 (.f64 re #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 re #s(literal 1/2 binary64)) re) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (.f64 re #s(literal 1/2 binary64)) (patch (.f64 re #s(literal 1/2 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log base))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf re) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf re) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2)) (taylor 0 im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (log im) (log base)) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (log im)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (/ (log re) (log base)) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* (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))) (taylor 0 im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (log im))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor 0 im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor 0 im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log base) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (log (/ 1 im)))) (taylor inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log base) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log base) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log base) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log base) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log base))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (* -1 (/ (log base) (log (/ 1 im))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 base) (log.f64 im)) (patch (/.f64 (log.f64 base) (log.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) (patch #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) (patch #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) (patch (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (neg.f64 im))) (patch #s(approx (+ ( (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (/ 1/2 (* im (log base))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (patch (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base)))) (taylor -inf im) (#s(alt (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (.f64 (log.f64 base) im)) (patch (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (patch #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) #<representation:binary64>) () ())) ())
#s(alt (* im (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) (patch (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base)) (taylor -inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64))) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)) #<representation:binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log base))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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)))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (+ (* -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))))))) (taylor -inf im) (#s(alt #s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) (patch #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #s(literal -1 binary64)))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 base) (log.f64 im))) (patch (log.f64 (/.f64 (log.f64 base) (log.f64 im))) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (taylor -inf im) (#s(alt (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) (patch (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 im (log.f64 base)) (patch (.f64 im (log.f64 base)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (* -1/2 (/ (pow re 2) (* im (log base)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) (patch (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (.f64 (neg.f64 re) re)) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (/.f64 (.f64 re re) im) (patch (/.f64 (.f64 re re) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())
#s(alt (* im (log base)) (taylor -inf im) (#s(alt (.f64 (log.f64 base) im) (patch (.f64 (log.f64 base) im) #<representation:binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
92.0ms	base	@	0	((/ 1 (/ (log base) (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log base) (log im)) (log base) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (* re 1/2) re) (* re 1/2) (/ (* (/ 1/2 (* im (log base))) (* (neg re) re)) (neg im)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* im (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (+ (* (/ (* re re) im) 1/2) (* (log im) im)) (exp (* (log (/ (log base) (log im))) -1)) (* (log (/ (log base) (log im))) -1) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (log (/ (log base) (log im))) (/ (* (* re 1/2) re) (* (* im (log base)) im)) (* im (log base)) (* (/ 1/2 (* im (log base))) (* (neg re) re)) (/ (* re re) im) (* (log base) im))
56.0ms	base	@	inf	((/ 1 (/ (log base) (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log base) (log im)) (log base) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (* re 1/2) re) (* re 1/2) (/ (* (/ 1/2 (* im (log base))) (* (neg re) re)) (neg im)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* im (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (+ (* (/ (* re re) im) 1/2) (* (log im) im)) (exp (* (log (/ (log base) (log im))) -1)) (* (log (/ (log base) (log im))) -1) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (log (/ (log base) (log im))) (/ (* (* re 1/2) re) (* (* im (log base)) im)) (* im (log base)) (* (/ 1/2 (* im (log base))) (* (neg re) re)) (/ (* re re) im) (* (log base) im))
50.0ms	base	@	-inf	((/ 1 (/ (log base) (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log base) (log im)) (log base) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (* re 1/2) re) (* re 1/2) (/ (* (/ 1/2 (* im (log base))) (* (neg re) re)) (neg im)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* im (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (+ (* (/ (* re re) im) 1/2) (* (log im) im)) (exp (* (log (/ (log base) (log im))) -1)) (* (log (/ (log base) (log im))) -1) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (log (/ (log base) (log im))) (/ (* (* re 1/2) re) (* (* im (log base)) im)) (* im (log base)) (* (/ 1/2 (* im (log base))) (* (neg re) re)) (/ (* re re) im) (* (log base) im))
44.0ms	im	@	-inf	((/ 1 (/ (log base) (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log base) (log im)) (log base) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (* re 1/2) re) (* re 1/2) (/ (* (/ 1/2 (* im (log base))) (* (neg re) re)) (neg im)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* im (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (+ (* (/ (* re re) im) 1/2) (* (log im) im)) (exp (* (log (/ (log base) (log im))) -1)) (* (log (/ (log base) (log im))) -1) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (log (/ (log base) (log im))) (/ (* (* re 1/2) re) (* (* im (log base)) im)) (* im (log base)) (* (/ 1/2 (* im (log base))) (* (neg re) re)) (/ (* re re) im) (* (log base) im))
33.0ms	re	@	inf	((/ 1 (/ (log base) (log im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log base) (log im)) (log base) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (* (* re 1/2) re) (* re 1/2) (/ (* (/ 1/2 (* im (log base))) (* (neg re) re)) (neg im)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/ 1/2 (* im (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (+ (* (/ (* re re) im) 1/2) (* (log im) im)) (exp (* (log (/ (log base) (log im))) -1)) (* (log (/ (log base) (log im))) -1) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (log (/ (log base) (log im))) (/ (* (* re 1/2) re) (* (* im (log base)) im)) (* im (log base)) (* (/ 1/2 (* im (log base))) (* (neg re) re)) (/ (* re re) im) (* (log base) im))

simplify278.0ms (2.2%)

Memory

16.0MiB live, 317.0MiB allocated

Algorithm

1×	egg-herbie

Rules

13 378×	`lower-fma.f64`
13 378×	`lower-fma.f32`
6 494×	`lower-*.f64`
6 494×	`lower-*.f32`
2 304×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	220	9666
1	564	9455
2	1565	9343
3	5436	9337
0	8354	8819

Stop Event

1×	iter limit
1×	node limit

Counts

708 → 708

Calls

Call 1

Inputs
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log base) (log im))
(/ (log base) (log im))
(/ (log base) (log im))
(/ (log base) (log im))
(log base)
(log base)
(log base)
(log base)
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log base)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))
(log (/ (log base) (log im)))
(log (/ (log base) (log im)))
(log (/ (log base) (log im)))
(log (/ (log base) (log im)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (/ 1 base)) (log im)))
(* -1 (/ (log (/ 1 base)) (log im)))
(* -1 (/ (log (/ 1 base)) (log im)))
(* -1 (/ (log (/ 1 base)) (log im)))
(* -1 (log (/ 1 base)))
(* -1 (log (/ 1 base)))
(* -1 (log (/ 1 base)))
(* -1 (log (/ 1 base)))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(/ -1/2 (* im (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(* -1 (/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (log (/ 1 base)))))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (/ (log im) (log (/ 1 base))))
(* -1 (log (* -1 (/ (log (/ 1 base)) (log im)))))
(* -1 (log (* -1 (/ (log (/ 1 base)) (log im)))))
(* -1 (log (* -1 (/ (log (/ 1 base)) (log im)))))
(* -1 (log (* -1 (/ (log (/ 1 base)) (log im)))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))
(log (* -1 (/ (log (/ 1 base)) (log im))))
(log (* -1 (/ (log (/ 1 base)) (log im))))
(log (* -1 (/ (log (/ 1 base)) (log im))))
(log (* -1 (/ (log (/ 1 base)) (log im))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* 1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* 1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* 1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* 1/2 (/ (pow re 2) (* im (log (/ 1 base)))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(* -1 (* im (log (/ 1 base))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))
(/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))
(/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))
(/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))
(+ (log -1) (* -1 (log (/ -1 base))))
(+ (log -1) (* -1 (log (/ -1 base))))
(+ (log -1) (* -1 (log (/ -1 base))))
(+ (log -1) (* -1 (log (/ -1 base))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ 1/2 (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(/ (+ (* 1/2 (/ (pow re 2) im)) (* im (log im))) (* im (+ (log -1) (* -1 (log (/ -1 base))))))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))
(* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))))
(* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))))
(* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))))
(* -1 (log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))
(log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))
(log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))
(log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))
(log (/ (+ (log -1) (* -1 (log (/ -1 base)))) (log im)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* -1/2 (/ (pow re 2) (* im (+ (log -1) (* -1 (log (/ -1 base)))))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(* im (+ (log -1) (* -1 (log (/ -1 base)))))
(/ (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 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 base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (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 base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(/ (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 base))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))
(* im (log im))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(* im (log im))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(+ (* 1/2 (/ (pow re 2) im)) (* im (log im)))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 (pow re 2))
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* -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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ (* im (log im)) (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/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log re) (log base))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))
(/ (log base) (log im))
(/ (log base) (log im))
(/ (log base) (log im))
(/ (log base) (log im))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ (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)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) im)
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(/ (log im) (log base))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(* -1 (log (/ (log base) (log im))))
(/ (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 (/ (log base) (log im)))
(log (/ (log base) (log im)))
(log (/ (log base) (log im)))
(log (/ (log base) (log im)))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
(* -1 (/ (log base) (log (/ 1 im))))
(* -1 (/ (log base) (log (/ 1 im))))
(* -1 (/ (log base) (log (/ 1 im))))
(* -1 (/ (log base) (log (/ 1 im))))
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* -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)) (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/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))
(* -1 (* im (log (/ 1 im))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* -1 (* im (log (/ 1 im))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (/ (log (/ 1 im)) (log base)))
(* -1 (log (* -1 (/ (log base) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log base) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log base) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log base) (log (/ 1 im))))))
(* -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)))))))
(log (* -1 (/ (log base) (log (/ 1 im)))))
(log (* -1 (/ (log base) (log (/ 1 im)))))
(log (* -1 (/ (log base) (log (/ 1 im)))))
(log (* -1 (/ (log base) (log (/ 1 im)))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(* -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)))))))
(/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))
(* -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)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* -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)) (log base))) (/ (log -1) (log base)))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(/ 1/2 (* im (log base)))
(* -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)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log base))
(* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -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)))))))
(log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log base) (+ (log -1) (* -1 (log (/ -1 im))))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(* -1/2 (/ (pow re 2) (* im (log base))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(* im (log base))
(* im (log base))
(* im (log base))
(* im (log base))

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

rewrite520.0ms (4.1%)

Memory

-103.6MiB live, 400.0MiB allocated

Rules

4 918×	`lower-fma.f32`
4 916×	`lower-fma.f64`
3 912×	`lower-/.f32`
3 898×	`lower-/.f64`
3 778×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	65	491
0	94	438
1	327	427
2	2795	426
0	8406	399

Stop Event

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

Counts

25 → 706

Calls

Call 1

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

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

eval443.0ms (3.5%)

Memory: 0.1MiB live, 422.3MiB allocated
Compiler: Compiled 26 498 to 2 744 computations (89.6% saved)

prune388.0ms (3%)

Memory

3.0MiB live, 451.6MiB allocated

Pruning

59 alts after pruning (55 fresh and 4 done)

	Pruned	Kept	Total
New	1 567	25	1 592
Fresh	17	30	47
Picked	2	3	5
Done	1	1	2
Total	1 587	59	1 646

Accuracy

99.8%

Counts

1 646 → 59

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) re) (/.f64 re im))))
	48.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 base)) #s(literal 1/2 binary64)) #s(literal 2 binary64)))
	93.9%	#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) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (log.f64 base) im) (log.f64 im))) (.f64 (.f64 (log.f64 base) im) (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 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) re) re) (/.f64 (log.f64 base) (log.f64 im)) (.f64 im #s(literal 1 binary64))) (*.f64 im (/.f64 (log.f64 base) (log.f64 im)))))
	94.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (log.f64 base)) im))
	47.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	98.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (*.f64 (log.f64 base) im)))
	52.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) im)) (.f64 (log.f64 base) im)))
	35.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (.f64 (fma.f64 (/.f64 (log.f64 im) re) (/.f64 im re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re))) (*.f64 (log.f64 base) im)))
	98.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (.f64 (log.f64 im) im)) (.f64 (log.f64 base) im)))
	94.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im (log.f64 base)) #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))))))
✓	99.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
	94.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 im (/.f64 #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (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 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 base)))))
	98.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (.f64 (pow.f64 (/.f64 (fma.f64 (.f64 re (log.f64 base)) (.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base)))) (*.f64 (log.f64 im) im)) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -1 binary64)))))
	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 base))))
	96.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (/.f64 (.f64 im (log.f64 base)) (.f64 (log.f64 base) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re (*.f64 (log.f64 im) im)))))))
	94.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (pow.f64 (.f64 im (log.f64 base)) #s(literal -1 binary64)) #s(approx (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)))))
	94.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 im #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im)))) #s(literal -1 binary64))))
	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (log.f64 im)))
	94.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (.f64 (pow.f64 im #s(literal -1 binary64)) (/.f64 #s(approx (+ ( (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (fma.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64) (.f64 (log.f64 im) im))) (log.f64 base))))
	36.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (-.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 base)))))
	48.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 base)))))
	50.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (/.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re) (.f64 (.f64 im (/.f64 im (log.f64 base))) (log.f64 im))) (.f64 im im))))
	49.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 re (log.f64 base))) (/.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 base) im)) im)) (.f64 re re))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (/ (+ (* (* (* (/ 1/2 (* (log base) im)) re) re) (log base)) (* im (log im))) (* (log base) im)) (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) im)) im) re) re)))
	50.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (fma.f64 (.f64 (/.f64 im (log.f64 base)) (log.f64 im)) im (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re)) (.f64 im im))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (neg.f64 re) re)) (log.f64 base)) (neg.f64 im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 re (log.f64 base)) (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) im)))
✓	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (neg.f64 re) re)) (neg.f64 im))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (.f64 re re)) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) #s(literal 1 binary64)) (.f64 im (/.f64 (/.f64 im re) re)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) #s(literal 1 binary64)) (.f64 im (/.f64 im (*.f64 re re))))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re (log.f64 base)) re)) im)))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re)) (*.f64 im (log.f64 base)))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) im) re) re) (log.f64 base))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im)) (neg.f64 re)) (neg.f64 im))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 (/.f64 re (log.f64 base)) #s(literal 1/2 binary64)) re) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re) im)))
✓	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 im (log.f64 base)) im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 (.f64 re (.f64 (/.f64 #s(literal 1/2 binary64) im) re)) (*.f64 im (log.f64 base)))))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(approx (+ (* (* (log im) im) (/ im (log base))) (* (* 1/2 re) (/ re (log base)))) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) re) re)) (*.f64 im im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(approx (* (/ 1/2 (* im (log base))) (* (neg re) re)) (.f64 re (.f64 re (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 base)) im)))) (neg.f64 im))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im (log.f64 base)) (.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1 binary64) (/.f64 im (.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) re)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (/.f64 #s(literal 1/2 binary64) (.f64 (/.f64 im (.f64 re re)) (*.f64 im (log.f64 base))))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (/.f64 re (.f64 im (log.f64 base))) im) (*.f64 #s(literal 1/2 binary64) re))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1/2 binary64) (log.f64 base)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) im) (/.f64 re (log.f64 base)))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))) im) re)))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) im) (/.f64 re (*.f64 im (log.f64 base))))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 re im) (.f64 (/.f64 re (log.f64 base)) (/.f64 #s(literal 1/2 binary64) im)))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 re im) (.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im (log.f64 base)))))))
	3.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im (log.f64 base))) (*.f64 (/.f64 re im) re))))
	3.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) (*.f64 im (log.f64 base))))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (/.f64 re (log.f64 base)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im)) re)))
	3.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 (.f64 (neg.f64 re) re) (/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) (log.f64 base)) (neg.f64 im)))))
	3.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (.f64 re (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (.f64 im (log.f64 base)) im)))))

Compiler

Compiled 2 990 to 1 271 computations (57.5% saved)

regimes244.0ms (1.9%)

Memory

29.2MiB live, 256.4MiB allocated

Counts

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

Calls

5 calls:

66.0ms	im
56.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))))
51.0ms	re
33.0ms	base
31.0ms	(log.f64 base)

Results

Accuracy	Segments	Branch
99.2%	1	`re`
99.2%	1	`im`
99.2%	1	`base`
99.2%	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.2%	1	`(log.f64 base)`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes108.0ms (0.8%)

Memory

-27.1MiB live, 174.4MiB allocated

Counts

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

28.0ms	base
23.0ms	(log.f64 base)
18.0ms	im
18.0ms	re
15.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes119.0ms (0.9%)

Memory

21.2MiB live, 133.7MiB allocated

Counts

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

Outputs

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

Calls

5 calls:

46.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))))
35.0ms	base
13.0ms	re
11.0ms	(log.f64 base)
11.0ms	im

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes73.0ms (0.6%)

Memory

15.3MiB live, 157.4MiB allocated

Counts

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

Outputs

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

Calls

5 calls:

19.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))))
14.0ms	(log.f64 base)
13.0ms	re
13.0ms	base
10.0ms	im

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes59.0ms (0.5%)

Memory

14.3MiB live, 170.7MiB allocated

Counts

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

Outputs

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

Calls

5 calls:

16.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))))
12.0ms	im
11.0ms	re
9.0ms	base
8.0ms	(log.f64 base)

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes79.0ms (0.6%)

Memory

-53.6MiB live, 123.9MiB allocated

Counts

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

Outputs

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

Calls

5 calls:

33.0ms	im
20.0ms	base
9.0ms	re
8.0ms	(log.f64 base)
7.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
3.5%	1	`base`
3.5%	1	`(log.f64 base)`
3.5%	1	`im`
3.5%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
3.5%	1	`re`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes45.0ms (0.4%)

Memory

-16.2MiB live, 140.7MiB allocated

Counts

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

Outputs

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

Calls

5 calls:

11.0ms	(log.f64 base)
8.0ms	re
8.0ms	base
8.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))))
7.0ms	im

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes24.0ms (0.2%)

Memory

8.3MiB live, 46.6MiB allocated

Counts

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

Calls

5 calls:

5.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))))
4.0ms	(log.f64 base)
4.0ms	re
4.0ms	base
4.0ms	im

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes11.0ms (0.1%)

Memory

-15.6MiB live, 23.4MiB allocated

Counts

3 → 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))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (*.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) re) (*.f64 (*.f64 im (log.f64 base)) im)))))

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

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

Calls

5 calls:

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

Results

Accuracy	Segments	Branch
3.4%	1	`base`
3.4%	1	`(log.f64 base)`
3.4%	1	`im`
3.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))))`
3.4%	1	`re`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes9.0ms (0.1%)

Memory

17.5MiB live, 17.5MiB allocated

Accuracy

Total -0.1b remaining (-0.2%)

Threshold costs -0.1b (-0.2%)

Counts

2 → 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))) #s(approx (+ (* (/ 1/2 (* (log base) im)) (/ (* re re) im)) (/ (log im) (log base))) (*.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) re) (*.f64 (*.f64 im (log.f64 base)) im)))))

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

Outputs

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

Calls

5 calls:

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))))
2.0ms	re
2.0ms	im
1.0ms	base

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify27.0ms (0.2%)

Memory

7.2MiB live, 51.5MiB allocated

Algorithm

1×	egg-herbie

Rules

30×	`-commutative-binary64-.f64`
2×	`-rgt-identity-binary64-.f64`
2×	`1-exp-binary32-exp.f32`
2×	`1-exp-binary64-exp.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	81	540
1	99	540

Stop Event

1×

saturated

Calls

Call 1

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

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

soundness1.1s (8.9%)

Memory

-4.5MiB live, 798.8MiB allocated

Rules

14 072×	`lower-fma.f64`
14 072×	`lower-fma.f32`
12 210×	`lower-fma.f64`
12 210×	`lower-fma.f32`
6 480×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	65	491
0	94	438
1	327	427
2	2795	426
0	8406	399
0	59	281
0	95	203
1	283	193
2	2070	193
0	8225	169
0	299	2912
1	840	2860
2	2641	2828
3	6330	2818
0	8095	2552
0	67	586
0	106	517
1	370	499
2	2747	499
0	8575	478
0	270	6456
1	689	6303
2	2049	6207
3	7694	6207
0	8051	5769

Stop Event

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

Compiler

Compiled 456 to 330 computations (27.6% saved)

preprocess290.0ms (2.3%)

Memory: -23.7MiB live, 209.9MiB allocated
Compiler: Compiled 1 084 to 692 computations (36.2% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze169.0ms (1.3%)

sample2.1s (16.9%)

explain320.0ms (2.5%)

preprocess220.0ms (1.7%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify210.0ms (1.7%)

localize65.0ms (0.5%)

series161.0ms (1.3%)

simplify180.0ms (1.4%)

rewrite270.0ms (2.1%)

eval231.0ms (1.8%)

prune44.0ms (0.3%)

simplify126.0ms (1%)

localize164.0ms (1.3%)

series219.0ms (1.7%)

simplify293.0ms (2.3%)

rewrite400.0ms (3.1%)

eval686.0ms (5.4%)

prune151.0ms (1.2%)

simplify220.0ms (1.7%)

localize180.0ms (1.4%)

series391.0ms (3.1%)

simplify362.0ms (2.8%)

rewrite251.0ms (2%)

eval398.0ms (3.1%)

prune226.0ms (1.8%)

simplify108.0ms (0.8%)

localize222.0ms (1.7%)

series446.0ms (3.5%)

simplify278.0ms (2.2%)

rewrite520.0ms (4.1%)

eval443.0ms (3.5%)

prune388.0ms (3%)

regimes244.0ms (1.9%)

regimes108.0ms (0.8%)

regimes119.0ms (0.9%)

regimes73.0ms (0.6%)

regimes59.0ms (0.5%)

regimes79.0ms (0.6%)

regimes45.0ms (0.4%)

regimes24.0ms (0.2%)

regimes11.0ms (0.1%)

regimes9.0ms (0.1%)

simplify27.0ms (0.2%)

soundness1.1s (8.9%)

preprocess290.0ms (2.3%)

end0.0ms (0%)

Profiling