math.log10 on complex, real part

Time bar (total: 6.5s)

analyze89.0ms (1.4%)

Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
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%99.9%0.1%0%0%0%4
18.8%18.7%81.2%0.1%0%0%0%5
34.4%34.3%65.6%0.1%0%0%0%6
54.7%54.6%45.3%0.1%0%0%0%7
64.8%64.8%35.1%0.1%0%0%0%8
76.2%76.1%23.8%0.1%0%0%0%9
81.8%81.8%18.1%0.1%0%0%0%10
87.8%87.7%12.2%0.1%0%0%0%11
90.8%90.7%9.2%0.1%0%0%0%12
Compiler

Compiled 15 to 11 computations (26.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 48.0ms
ival-log: 18.0ms (37.7% of total)
ival-mult: 12.0ms (25.1% of total)
ival-sqrt: 8.0ms (16.8% of total)
ival-div: 6.0ms (12.6% of total)
ival-add: 4.0ms (8.4% of total)
const: 1.0ms (2.1% of total)
backward-pass: 0.0ms (0% of total)

sample1.2s (18.4%)

Results
933.0ms8256×0valid
Precisions
Click to see histograms. Total time spent on operations: 665.0ms
ival-log: 237.0ms (35.6% of total)
ival-mult: 175.0ms (26.3% of total)
ival-div: 111.0ms (16.7% of total)
ival-sqrt: 71.0ms (10.7% of total)
ival-add: 55.0ms (8.3% of total)
const: 13.0ms (2% of total)
backward-pass: 3.0ms (0.5% of total)
Bogosity

preprocess27.0ms (0.4%)

Algorithm
2×egg-herbie
Rules
184×fmsub-define
160×fnmadd-define
148×fnmsub-define
132×sum3-define
118×fma-define
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02844
16144
211644
324744
446444
563544
672044
773844
877344
977544
1077644
0107
1137
2157
0157
Stop Event
1×iter limit
1×saturated
1×saturated
Calls
Call 1
Inputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
Outputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
Call 2
Inputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(/ (log (sqrt (+ (* (neg re) (neg re)) (* im im)))) (log 10))
(/ (log (sqrt (+ (* re re) (* (neg im) (neg im))))) (log 10))
(neg (/ (log (sqrt (+ (* (neg re) (neg re)) (* im im)))) (log 10)))
(neg (/ (log (sqrt (+ (* re re) (* (neg im) (neg im))))) (log 10)))
(/ (log (sqrt (+ (* im im) (* re re)))) (log 10))
Outputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(/ (log (hypot re im)) (log 10))
(/ (log (sqrt (+ (* (neg re) (neg re)) (* im im)))) (log 10))
(/ (log (hypot re im)) (log 10))
(/ (log (sqrt (+ (* re re) (* (neg im) (neg im))))) (log 10))
(/ (log (hypot re im)) (log 10))
(neg (/ (log (sqrt (+ (* (neg re) (neg re)) (* im im)))) (log 10)))
(/ (log (hypot re im)) (neg (log 10)))
(neg (/ (log (sqrt (+ (* re re) (* (neg im) (neg im))))) (log 10)))
(/ (log (hypot re im)) (neg (log 10)))
(/ (log (sqrt (+ (* im im) (* re re)))) (log 10))
(/ (log (hypot re im)) (log 10))
Symmetry

(abs re)

(abs im)

(sort re im)

explain103.0ms (1.6%)

FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1280-1(2.1723878314281598e-237 1.1763033763705416e-158)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
00-0-(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
00-0-#s(literal 10 binary64)
00-0-(*.f64 im im)
00-0-re
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-im
00-0-(*.f64 re re)
00-0-(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
00-0-(log.f64 #s(literal 10 binary64))
Results
63.0ms512×0valid
Compiler

Compiled 114 to 32 computations (71.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 34.0ms
ival-log: 13.0ms (38.2% of total)
ival-mult: 9.0ms (26.4% of total)
ival-div: 4.0ms (11.8% of total)
ival-sqrt: 4.0ms (11.8% of total)
ival-add: 3.0ms (8.8% of total)
const: 1.0ms (2.9% of total)
backward-pass: 0.0ms (0% of total)

eval0.0ms (0%)

Compiler

Compiled 9 to 7 computations (22.2% saved)

prune1.0ms (0%)

Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶51.5%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 23 to 17 computations (26.1% saved)

simplify6.0ms (0.1%)

Algorithm
1×egg-herbie
Localize:

Found 8 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(hypot.f64 re im)
✓cost-diff0
(log.f64 (hypot.f64 re im))
✓cost-diff0
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓cost-diff0
(+.f64 (*.f64 re re) (*.f64 im im))
✓cost-diff320
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff320
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓cost-diff320
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Rules
4×fma-lowering-fma.f32
4×fma-define
4×+-lowering-+.f64
4×hypot-lowering-hypot.f64
4×log-lowering-log.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01050
11350
21550
01550
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
(log 10)
10
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
re
im
(log 10)
10
Outputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (hypot.f64 re im))
(sqrt (+ (* re re) (* im im)))
(hypot.f64 re im)
(+ (* re re) (* im im))
(+.f64 (*.f64 re re) (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (hypot.f64 re im))
(sqrt (+ (* re re) (* im im)))
(hypot.f64 re im)
re
im
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)

localize68.0ms (1%)

Localize:

Found 8 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(hypot.f64 re im)
✓accuracy100.0%
(log.f64 (hypot.f64 re im))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓accuracy100.0%
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.1%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓accuracy53.6%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Results
49.0ms256×0valid
Compiler

Compiled 69 to 14 computations (79.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 39.0ms
ival-mult: 11.0ms (27.9% of total)
ival-log: 9.0ms (22.8% of total)
compiled-spec: 9.0ms (22.8% of total)
ival-div: 4.0ms (10.1% of total)
ival-sqrt: 4.0ms (10.1% of total)
ival-add: 3.0ms (7.6% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

series15.0ms (0.2%)

Counts
8 → 168
Calls
Call 1
Inputs
#<alt (/ (log (sqrt (+ (* re re) (* im im)))) (log 10))>
#<alt (log (sqrt (+ (* re re) (* im im))))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (+ (* re re) (* im im))>
#<alt (/ (log (sqrt (+ (* re re) (* im im)))) (log 10))>
#<alt (log (sqrt (+ (* re re) (* im im))))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (log 10)>
Outputs
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (/ (log re) (log 10))>
#<alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (/ (log re) (log 10))>
#<alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
Calls

42 calls:

TimeVariablePointExpression
3.0ms
im
@0
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
2.0ms
re
@0
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
1.0ms
re
@inf
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
1.0ms
im
@inf
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
1.0ms
re
@inf
(log (sqrt (+ (* re re) (* im im))))

rewrite336.0ms (5.1%)

Algorithm
1×batch-egg-rewrite
Rules
2618×*-lowering-*.f32
2618×*-lowering-*.f64
2306×fma-lowering-fma.f32
2306×fma-lowering-fma.f64
1736×fma-define
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01036
13936
226936
3251936
0861336
Stop Event
1×iter limit
1×node limit
Counts
8 → 323
Calls
Call 1
Inputs
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(log 10)
Outputs
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (hypot.f64 re im))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (log.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))) (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (+.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (hypot.f64 re im)))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (hypot.f64 re im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (hypot.f64 re im)) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64))
(*.f64 (hypot.f64 re im) (pow.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (hypot.f64 re im) (pow.f64 (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (pow.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64)) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))
(*.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 im im) (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)) (hypot.f64 re im))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (hypot.f64 re im))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (pow.f64 (+.f64 re im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (pow.f64 (pow.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 im im) (*.f64 re re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 re re) (*.f64 im im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(neg.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(neg.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))) (+.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))) (+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (+.f64 re im)) (-.f64 re im))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(*.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))
(*.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(*.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 im im) (*.f64 re re))))
(*.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 re re) (*.f64 im im)))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))
(*.f64 (pow.f64 (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (pow.f64 (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (hypot.f64 re im))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (log.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))) (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (+.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (hypot.f64 re im)))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (hypot.f64 re im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (hypot.f64 re im)) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64))
(*.f64 (hypot.f64 re im) (pow.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (hypot.f64 re im) (pow.f64 (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) (pow.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/2 binary64)) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))
(*.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 im im) (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)) (hypot.f64 re im))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (hypot.f64 re im))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (pow.f64 (+.f64 re im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (pow.f64 (pow.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (-.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(log.f64 #s(literal 10 binary64))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))

simplify253.0ms (3.9%)

Algorithm
1×egg-herbie
Rules
3598×*-lowering-*.f32
3598×*-lowering-*.f64
2272×+-lowering-+.f64
2272×+-lowering-+.f32
1776×sum4-define
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
02683088
18162954
227342938
370332938
080252938
Stop Event
1×iter limit
1×node limit
Counts
168 → 168
Calls
Call 1
Inputs
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(+ 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)))))
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 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))))))))
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)))))
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 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))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(+ 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)))))
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 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))))))))
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)))))
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 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 im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+.f64 (*.f64 re (*.f64 re (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (*.f64 re (*.f64 re (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))) (*.f64 im (*.f64 im (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (log.f64 im) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (-.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/6 binary64))) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (log.f64 im) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+.f64 im (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+.f64 im (*.f64 re (*.f64 re (+.f64 (/.f64 (*.f64 re (*.f64 re #s(literal -1/8 binary64))) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 im (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 1/16 binary64))) (pow.f64 im #s(literal 5 binary64))) (/.f64 (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) im))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(*.f64 re (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 #s(literal -1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (-.f64 #s(literal 0 binary64) re))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal -1/8 binary64))) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/16 binary64))) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re))))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.f64 im (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 im (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im 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 im (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (*.f64 (/.f64 (*.f64 im (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64)) im)
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) im))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+.f64 (*.f64 re (*.f64 re (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (*.f64 re (*.f64 re (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (log.f64 #s(literal 10 binary64)) re))) (*.f64 im (*.f64 im (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (log.f64 im) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (-.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/6 binary64))) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (log.f64 im) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (log.f64 im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+.f64 im (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+.f64 im (*.f64 re (*.f64 re (+.f64 (/.f64 (*.f64 re (*.f64 re #s(literal -1/8 binary64))) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 im (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 1/16 binary64))) (pow.f64 im #s(literal 5 binary64))) (/.f64 (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) im))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(*.f64 re (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 #s(literal -1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (-.f64 #s(literal 0 binary64) re))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal -1/8 binary64))) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 im (*.f64 im #s(literal 1/16 binary64))) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re))))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.f64 im (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 im (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im 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 im (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (*.f64 (/.f64 (*.f64 im (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64)) im)
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) im))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 re (*.f64 #s(literal 1/2 binary64) re)) im) im) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) im))

eval77.0ms (1.2%)

Compiler

Compiled 14205 to 1151 computations (91.9% saved)

prune66.0ms (1%)

Pruning

8 alts after pruning (7 fresh and 1 done)

PrunedKeptTotal
New4957502
Fresh000
Picked112
Done000
Total4968504
Accuracy
99.8%
Counts
504 → 8
Alt Table
Click to see full alt table
StatusAccuracyProgram
31.5%
(pow.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
▶51.5%
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶51.3%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
▶99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶97.8%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
51.4%
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
▶51.4%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
Compiler

Compiled 209 to 161 computations (23% saved)

simplify27.0ms (0.4%)

Algorithm
1×egg-herbie
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
✓cost-diff128
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
✓cost-diff0
(+.f64 (*.f64 re re) (*.f64 im im))
✓cost-diff0
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff0
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
✓cost-diff0
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓cost-diff0
(+.f64 (*.f64 re re) (*.f64 im im))
✓cost-diff0
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff0
(*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓cost-diff0
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓cost-diff-64
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(hypot.f64 re im)
✓cost-diff0
(log.f64 (hypot.f64 re im))
Rules
294×fma-define
220×sum3-define
144×fmsub-define
120×fma-lowering-fma.f32
120×fma-lowering-fma.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
026185
144185
271185
397185
4128185
5160185
6204185
7265185
8348185
9441185
10526185
11650185
12760185
13763185
14764185
0764185
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10)))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
re
im
(neg (log 1/10))
(log 1/10)
1/10
(/ (log im) (log 10))
(log im)
im
(log 10)
10
(/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10))
(* -1/2 (log (+ (* re re) (* im im))))
-1/2
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
(log 1/10)
1/10
(/ (* (log (+ (* re re) (* im im))) 1/2) (log 10))
(* (log (+ (* re re) (* im im))) 1/2)
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
1/2
(log 10)
10
(/ -1 (/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im))))))
-1
(/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im)))))
(log 1/10)
1/10
(* 1/2 (log (+ (* re re) (* im im))))
1/2
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
Outputs
(/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10)))
(/.f64 (log.f64 (hypot.f64 re im)) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (hypot.f64 re im))
(sqrt (+ (* re re) (* im im)))
(hypot.f64 re im)
re
im
(neg (log 1/10))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
im
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(* -1/2 (log (+ (* re re) (* im im))))
(*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
-1/2
#s(literal -1/2 binary64)
(log (+ (* re re) (* im im)))
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+ (* re re) (* im im))
(+.f64 (*.f64 re re) (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
(/ (* (log (+ (* re re) (* im im))) 1/2) (log 10))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(* (log (+ (* re re) (* im im))) 1/2)
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(log (+ (* re re) (* im im)))
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+ (* re re) (* im im))
(+.f64 (*.f64 re re) (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im
1/2
#s(literal 1/2 binary64)
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(/ -1 (/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im))))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
-1
#s(literal -1 binary64)
(/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im)))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
(* 1/2 (log (+ (* re re) (* im im))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
1/2
#s(literal 1/2 binary64)
(log (+ (* re re) (* im im)))
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+ (* re re) (* im im))
(+.f64 (*.f64 re re) (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im

localize181.0ms (2.8%)

Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓accuracy99.6%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
✓accuracy99.0%
(/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
✓accuracy51.9%
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.1%
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓accuracy51.9%
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓accuracy100.0%
(*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓accuracy99.1%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
✓accuracy51.9%
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.1%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓accuracy100.0%
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
✓accuracy100.0%
(log.f64 (hypot.f64 re im))
✓accuracy99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
Results
130.0ms256×0valid
Compiler

Compiled 203 to 27 computations (86.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 69.0ms
ival-log: 17.0ms (24.5% of total)
ival-div: 16.0ms (23.1% of total)
ival-mult: 16.0ms (23.1% of total)
compiled-spec: 9.0ms (13% of total)
...c/correct-round.rkt:119:19: 4.0ms (5.8% of total)
ival-add: 3.0ms (4.3% of total)
ival-sqrt: 2.0ms (2.9% of total)
const: 1.0ms (1.4% of total)
ival-neg: 1.0ms (1.4% of total)
backward-pass: 0.0ms (0% of total)

series104.0ms (1.6%)

Counts
18 → 324
Calls
Call 1
Inputs
#<alt (log (sqrt (+ (* re re) (* im im))))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (log 1/10)>
#<alt (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10)))>
#<alt (/ (log im) (log 10))>
#<alt (log im)>
#<alt (log 10)>
#<alt (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10))>
#<alt (* -1/2 (log (+ (* re re) (* im im))))>
#<alt (log (+ (* re re) (* im im)))>
#<alt (+ (* re re) (* im im))>
#<alt (/ (* (log (+ (* re re) (* im im))) 1/2) (log 10))>
#<alt (* (log (+ (* re re) (* im im))) 1/2)>
#<alt (/ -1 (/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im))))))>
#<alt (/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im)))))>
#<alt (* 1/2 (log (+ (* re re) (* im im))))>
#<alt (neg (log 1/10))>
#<alt (* im im)>
Outputs
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))>
#<alt (/ (log (/ -1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))>
#<alt (* -1 (/ (log re) (log 1/10)))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (/ (log (/ -1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (* -1/2 (/ (log (pow im 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))>
#<alt (/ (log (/ -1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))>
#<alt (* -1/2 (/ (log (pow re 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (/ (log (/ -1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))>
#<alt (* -1/2 (log (pow im 2)))>
#<alt (+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (log (/ 1 re))>
#<alt (+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))>
#<alt (+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))>
#<alt (log (/ -1 re))>
#<alt (+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))>
#<alt (+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))>
#<alt (* -1/2 (log (pow re 2)))>
#<alt (+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (log (/ 1 im))>
#<alt (+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))>
#<alt (+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))>
#<alt (log (/ -1 im))>
#<alt (+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))>
#<alt (+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))>
#<alt (log (pow im 2))>
#<alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))>
#<alt (* -2 (log (/ 1 re)))>
#<alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (* -2 (log (/ -1 re)))>
#<alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (log (pow re 2))>
#<alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* 1/2 (/ (log (pow im 2)) (log 10)))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* 1/2 (/ (log (pow re 2)) (log 10)))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* 1/2 (log (pow im 2)))>
#<alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* 1/2 (log (pow re 2)))>
#<alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1/2 (/ (log (pow im 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))>
#<alt (/ (log (/ -1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))>
#<alt (* -1/2 (/ (log (pow re 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (/ (log (/ -1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))>
#<alt (* 2 (/ (log 1/10) (log (pow im 2))))>
#<alt (+ (* -2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 1/10) (log (pow im 2)))))>
#<alt (+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))>
#<alt (+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))>
#<alt (* -1 (/ (log 1/10) (log (/ 1 re))))>
#<alt (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))>
#<alt (* -1 (/ (log 1/10) (log (/ -1 re))))>
#<alt (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))>
#<alt (* 2 (/ (log 1/10) (log (pow re 2))))>
#<alt (+ (* -2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 1/10) (log (pow re 2)))))>
#<alt (+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))>
#<alt (+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))>
#<alt (* -1 (/ (log 1/10) (log (/ 1 im))))>
#<alt (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))>
#<alt (* -1 (/ (log 1/10) (log (/ -1 im))))>
#<alt (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))>
#<alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))>
#<alt (* 1/2 (log (pow im 2)))>
#<alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* 1/2 (log (pow re 2)))>
#<alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
Calls

81 calls:

TimeVariablePointExpression
48.0ms
im
@0
(/ (log im) (log 10))
12.0ms
im
@-inf
(/ (log im) (log 10))
8.0ms
im
@inf
(/ (log im) (log 10))
6.0ms
re
@0
(/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10))
3.0ms
im
@inf
(/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im)))))

rewrite367.0ms (5.6%)

Algorithm
1×batch-egg-rewrite
Rules
2540×fma-lowering-fma.f32
2540×fma-lowering-fma.f64
2014×*-lowering-*.f32
2014×*-lowering-*.f64
1824×fma-define
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
02693
110384
255384
3396684
0807284
Stop Event
1×iter limit
1×node limit
Counts
18 → 735
Calls
Call 1
Inputs
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(log 1/10)
(/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10)))
(/ (log im) (log 10))
(log im)
(log 10)
(/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10))
(* -1/2 (log (+ (* re re) (* im im))))
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(/ (* (log (+ (* re re) (* im im))) 1/2) (log 10))
(* (log (+ (* re re) (* im im))) 1/2)
(/ -1 (/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im))))))
(/ (log 1/10) (* 1/2 (log (+ (* re re) (* im im)))))
(* 1/2 (log (+ (* re re) (* im im))))
(neg (log 1/10))
(* im im)
Outputs
(log.f64 (hypot.f64 re im))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(+.f64 (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(hypot.f64 re im)
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (hypot.f64 re im)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (exp.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (exp.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(*.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(*.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))))
(*.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)))
(log.f64 #s(literal 1/10 binary64))
(+.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(neg.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(log.f64 im)
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) im)))
(+.f64 (log.f64 (pow.f64 im #s(literal 1/2 binary64))) (log.f64 (pow.f64 im #s(literal 1/2 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(neg.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(neg.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(log.f64 (/.f64 #s(literal 1 binary64) (hypot.f64 re im)))
(+.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (hypot.f64 re im) #s(literal 1 binary64))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (hypot.f64 re im))))
(-.f64 (log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64)))) (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))))
(neg.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))))
(+.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 #s(literal 0 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(+.f64 (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (log.f64 (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (log.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(+.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(+.f64 (log.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 im im) (*.f64 re re)))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(+.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))
(+.f64 (log.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (log.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 re im))) (log.f64 (+.f64 re im)))
(+.f64 (log.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))) (log.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(+.f64 (log.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(+.f64 (log.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(-.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (log.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(-.f64 (log.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.f64 (*.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (neg.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (-.f64 (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64)))) (log.f64 (+.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))))))
(-.f64 (log.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))) (log.f64 (+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(-.f64 (log.f64 (*.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(-.f64 (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))) (log.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))) (log.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))) (log.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 (log.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (+.f64 re im))) (log.f64 (-.f64 re im)))
(neg.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 3 binary64))) (+.f64 (*.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (+.f64 (*.f64 (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))) (*.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64))) (+.f64 (*.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (+.f64 (*.f64 (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (log.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))) (log.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (-.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 (*.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 im im) (*.f64 re re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (-.f64 (*.f64 re re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re re) (*.f64 im im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(neg.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (+.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im))))) (+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (+.f64 re im)) (-.f64 re im))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (*.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im))))
(*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))
(*.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (*.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))
(*.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))
(*.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 im im) (*.f64 re re))))
(*.f64 (/.f64 (+.f64 (*.f64 re re) (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re re) (*.f64 im im)))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))) (+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))
(*.f64 (/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 re re) (*.f64 im im)))))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(neg.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(log.f64 (hypot.f64 re im))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(+.f64 (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(neg.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(neg.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))))
(/.f64 #s(literal 2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (*.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1/2 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 0 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal 2 binary64) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 2 binary64))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -2 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(log.f64 (hypot.f64 re im))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(+.f64 (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (+.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/4 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)) #s(literal 1/2 binary64))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))) (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (log.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (-.f64 (*.f64 im im) (*.f64 re re)))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))) (*.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 re re) (*.f64 im im))))) #s(literal 1/2 binary64))
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(*.f64 im im)

simplify356.0ms (5.4%)

Algorithm
1×egg-herbie
Rules
5640×*-lowering-*.f32
5640×*-lowering-*.f64
3800×+-lowering-+.f64
3800×+-lowering-+.f32
2384×/-lowering-/.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
07016820
123016644
083416644
Stop Event
1×iter limit
1×node limit
Counts
324 → 324
Calls
Call 1
Inputs
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(+ 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)))))
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 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))))))))
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)))))
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 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 im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (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/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* -1/2 (log (pow im 2)))
(+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(log (/ 1 re))
(+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(log (/ -1 re))
(+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(* -1/2 (log (pow re 2)))
(+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(log (/ 1 im))
(+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(log (/ -1 im))
(+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* 2 (/ (log 1/10) (log (pow im 2))))
(+ (* -2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 1/10) (log (pow im 2)))))
(+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(* -1 (/ (log 1/10) (log (/ 1 re))))
(+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(* -1 (/ (log 1/10) (log (/ -1 re))))
(+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(* 2 (/ (log 1/10) (log (pow re 2))))
(+ (* -2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 1/10) (log (pow re 2)))))
(+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(* -1 (/ (log 1/10) (log (/ -1 im))))
(+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
Outputs
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))))))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (+.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (log.f64 re) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+.f64 im (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re re)) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 im (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(*.f64 re (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) 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)))))
(+.f64 re (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) re) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re))))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.f64 im (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) #s(literal 1 binary64)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 im (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 im (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))))))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (-.f64 #s(literal 0 binary64) im))
(* -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 (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(-.f64 (*.f64 (*.f64 re re) (+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+.f64 (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(+.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))) (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(-.f64 (*.f64 (*.f64 im im) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(+.f64 (+.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal -1/720 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal -1/720 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log 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.f64 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)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (*.f64 (/.f64 re (*.f64 im im)) (/.f64 re (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+.f64 (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(+.f64 (+.f64 (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(+.f64 (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(* -1/2 (log (pow im 2)))
(*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 im im))) (*.f64 re (*.f64 re (+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 im im))))))
(log (/ 1 re))
(log.f64 (/.f64 #s(literal 1 binary64) re))
(+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 re))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 re)) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 re)) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(log (/ -1 re))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(* -1/2 (log (pow re 2)))
(*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 re re)))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 re re)))))
(log (/ 1 im))
(-.f64 #s(literal 0 binary64) (log.f64 im))
(+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im)) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im)) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))))
(log (/ -1 im))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+.f64 (log.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(+.f64 (log.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/3 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))))))))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (+.f64 (neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64))) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(+.f64 (neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64))) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(+.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+.f64 (log.f64 (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 re re)) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(+.f64 (log.f64 (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 im (*.f64 im (+.f64 (/.f64 (*.f64 #s(literal 1/3 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))))))))
(* -2 (log (/ 1 im)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal -2 binary64))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(+.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal -2 binary64)) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(+.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(+ (pow im 2) (pow re 2))
(+.f64 (*.f64 re re) (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+.f64 (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (+.f64 (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (-.f64 (+.f64 (/.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+.f64 (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))))) (/.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (log (pow im 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* 1/2 (log (pow re 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (*.f64 (/.f64 re (*.f64 im im)) (/.f64 re (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+.f64 (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(+.f64 (+.f64 (-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (/.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 (log.f64 (*.f64 re re)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(+.f64 (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(* 2 (/ (log 1/10) (log (pow im 2))))
(/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 im im)))
(+ (* -2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 1/10) (log (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))
(+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 #s(literal -2 binary64) (+.f64 (*.f64 (*.f64 re re) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64))))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))))))
(+ (* 2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 #s(literal -2 binary64) (+.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (*.f64 re (*.f64 re (-.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/3 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (/.f64 (-.f64 (/.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (*.f64 (*.f64 im im) (log.f64 (*.f64 im im)))))))))))))
(* -1 (/ (log 1/10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)) (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(+.f64 (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)) (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))))) (/.f64 (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))))) (pow.f64 re #s(literal 4 binary64))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(+.f64 (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)) (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))))) (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal 1 binary64) re))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 (*.f64 #s(literal 1/12 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 re #s(literal 6 binary64))))))
(* -1 (/ (log 1/10) (log (/ -1 re))))
(/.f64 (*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (*.f64 re re))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (*.f64 re re))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (pow.f64 re #s(literal 4 binary64))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (*.f64 re re))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/12 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (pow.f64 re #s(literal 6 binary64))))))
(* 2 (/ (log 1/10) (log (pow re 2))))
(/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 re re)))
(+ (* -2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 1/10) (log (pow re 2)))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (*.f64 re re))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))
(+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 #s(literal -2 binary64) (+.f64 (*.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64))))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))))))
(+ (* 2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(+.f64 (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (+.f64 (/.f64 (/.f64 (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 re re)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (*.f64 (*.f64 (*.f64 im im) #s(literal -2 binary64)) (+.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (*.f64 im (*.f64 im (-.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (/.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (*.f64 (*.f64 re re) (log.f64 (*.f64 re re))))))))))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64)))) (*.f64 im im))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(+.f64 (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64)))) (*.f64 im im)))) (/.f64 (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 4 binary64))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(+.f64 (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64)))) (*.f64 im im)))) (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 3 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 3 binary64))))) (-.f64 #s(literal 0 binary64) (log.f64 im))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 3 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/12 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 im #s(literal 6 binary64))))))
(* -1 (/ (log 1/10) (log (/ -1 im))))
(/.f64 (*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(+.f64 (-.f64 (/.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 4 binary64))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(+.f64 (-.f64 (/.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal -2 binary64) (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/12 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 im #s(literal 6 binary64))))))
(* 1/2 (log (pow im 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+.f64 (log.f64 re) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (+.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (+.f64 (log.f64 re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* 1/2 (log (pow re 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(+.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (+.f64 (log.f64 im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)

eval217.0ms (3.3%)

Compiler

Compiled 44836 to 3347 computations (92.5% saved)

prune249.0ms (3.8%)

Pruning

15 alts after pruning (10 fresh and 5 done)

PrunedKeptTotal
New149991508
Fresh112
Picked145
Done011
Total1501151516
Accuracy
100.0%
Counts
1516 → 15
Alt Table
Click to see full alt table
StatusAccuracyProgram
31.5%
(pow.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
51.3%
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
▶97.6%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓51.5%
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶97.7%
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓97.8%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
▶97.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
97.6%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
31.5%
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
▶98.0%
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
97.3%
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)))
▶71.9%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
Compiler

Compiled 342 to 255 computations (25.4% saved)

simplify133.0ms (2%)

Algorithm
1×egg-herbie
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓cost-diff0
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓cost-diff0
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
✓cost-diff12928
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 im))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff128
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓cost-diff128
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓cost-diff-64
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
✓cost-diff-64
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
✓cost-diff19456
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
Rules
2178×*-lowering-*.f32
2178×*-lowering-*.f64
1746×fnmadd-define
1556×sum3-define
1276×fma-define
Iterations

Useful iterations: 3 (0.0ms)

IterNodesCost
026143
152142
2102140
3248119
41213119
52109119
64619119
08636119
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))
(/ (log im) (- 0 (pow (log 1/10) 3)))
(log im)
im
(- 0 (pow (log 1/10) 3))
0
(pow (log 1/10) 3)
(log 1/10)
1/10
3
(pow (log 1/10) 2)
2
(/ (log im) (neg (log 1/10)))
(log im)
im
(neg (log 1/10))
(log 1/10)
1/10
(/ 1 (/ (log 10) (log im)))
1
(/ (log 10) (log im))
(log 10)
10
(log im)
im
(/ (/ -1 (log 1/10)) (/ 1 (log im)))
(/ -1 (log 1/10))
-1
(log 1/10)
1/10
(/ 1 (log im))
1
(log im)
im
(exp (* (log (/ (log 10) (log im))) -1))
(* (log (/ (log 10) (log im))) -1)
(log (/ (log 10) (log im)))
(/ (log 10) (log im))
(log 10)
10
(log im)
im
-1
Outputs
(* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log im) (- 0 (pow (log 1/10) 3)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(log im)
(log.f64 im)
im
(- 0 (pow (log 1/10) 3))
(-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
0
#s(literal 0 binary64)
(pow (log 1/10) 3)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
3
#s(literal 3 binary64)
(pow (log 1/10) 2)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
2
#s(literal 2 binary64)
(/ (log im) (neg (log 1/10)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(log im)
(log.f64 im)
im
(neg (log 1/10))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
(/ 1 (/ (log 10) (log im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
1
#s(literal 1 binary64)
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(log im)
(log.f64 im)
im
(/ (/ -1 (log 1/10)) (/ 1 (log im)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ -1 (log 1/10))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
-1
#s(literal -1 binary64)
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
1
#s(literal 1 binary64)
(log im)
(log.f64 im)
im
(exp (* (log (/ (log 10) (log im))) -1))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* (log (/ (log 10) (log im))) -1)
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(log im)
(log.f64 im)
im
-1
#s(literal -1 binary64)

localize143.0ms (2.2%)

Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.9%
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓accuracy99.2%
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓accuracy98.7%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
✓accuracy99.7%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓accuracy99.6%
(/.f64 #s(literal 1 binary64) (log.f64 im))
✓accuracy98.8%
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓accuracy99.2%
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓accuracy100.0%
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
✓accuracy100.0%
(log.f64 im)
✓accuracy99.3%
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy99.4%
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
✓accuracy98.8%
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy98.2%
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
Results
73.0ms189×0valid
27.0ms67×0invalid
Compiler

Compiled 143 to 28 computations (80.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 60.0ms
ival-pow: 18.0ms (29.8% of total)
ival-log: 15.0ms (24.8% of total)
ival-div: 13.0ms (21.5% of total)
ival-mult: 4.0ms (6.6% of total)
...c/correct-round.rkt:119:19: 4.0ms (6.6% of total)
ival-exp: 2.0ms (3.3% of total)
ival-sub: 2.0ms (3.3% of total)
const: 1.0ms (1.7% of total)
ival-neg: 1.0ms (1.7% of total)
backward-pass: 0.0ms (0% of total)

series102.0ms (1.6%)

Counts
18 → 132
Calls
Call 1
Inputs
#<alt (* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))>
#<alt (/ (log im) (- 0 (pow (log 1/10) 3)))>
#<alt (log im)>
#<alt (- 0 (pow (log 1/10) 3))>
#<alt (log 1/10)>
#<alt (/ (log im) (neg (log 1/10)))>
#<alt (neg (log 1/10))>
#<alt (/ 1 (/ (log 10) (log im)))>
#<alt (/ (log 10) (log im))>
#<alt (log 10)>
#<alt (/ (/ -1 (log 1/10)) (/ 1 (log im)))>
#<alt (/ -1 (log 1/10))>
#<alt (/ 1 (log im))>
#<alt (exp (* (log (/ (log 10) (log im))) -1))>
#<alt (* (log (/ (log 10) (log im))) -1)>
#<alt (log (/ (log 10) (log im)))>
#<alt (pow (log 1/10) 3)>
#<alt (pow (log 1/10) 2)>
Outputs
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (log im) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (log im) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (log im) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (log im) (pow (log 1/10) 3)))>
#<alt (/ (log (/ 1 im)) (pow (log 1/10) 3))>
#<alt (/ (log (/ 1 im)) (pow (log 1/10) 3))>
#<alt (/ (log (/ 1 im)) (pow (log 1/10) 3))>
#<alt (/ (log (/ 1 im)) (pow (log 1/10) 3))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
Calls

33 calls:

TimeVariablePointExpression
29.0ms
im
@0
(* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))
22.0ms
im
@inf
(* (log (/ (log 10) (log im))) -1)
19.0ms
im
@0
(* (log (/ (log 10) (log im))) -1)
18.0ms
im
@-inf
(* (log (/ (log 10) (log im))) -1)
2.0ms
im
@-inf
(* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))

rewrite325.0ms (5%)

Algorithm
1×batch-egg-rewrite
Rules
2930×*-lowering-*.f32
2930×*-lowering-*.f64
2106×/-lowering-/.f32
2106×/-lowering-/.f64
1226×fnmadd-define
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
026120
1120118
266477
3599577
0822577
Stop Event
1×iter limit
1×node limit
Counts
18 → 1729
Calls
Call 1
Inputs
(* (/ (log im) (- 0 (pow (log 1/10) 3))) (pow (log 1/10) 2))
(/ (log im) (- 0 (pow (log 1/10) 3)))
(log im)
(- 0 (pow (log 1/10) 3))
(log 1/10)
(/ (log im) (neg (log 1/10)))
(neg (log 1/10))
(/ 1 (/ (log 10) (log im)))
(/ (log 10) (log im))
(log 10)
(/ (/ -1 (log 1/10)) (/ 1 (log im)))
(/ -1 (log 1/10))
(/ 1 (log im))
(exp (* (log (/ (log 10) (log im))) -1))
(* (log (/ (log 10) (log im))) -1)
(log (/ (log 10) (log im)))
(pow (log 1/10) 3)
(pow (log 1/10) 2)
Outputs
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(+.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 #s(literal 0 binary64) (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(+.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(+.f64 (*.f64 #s(literal 0 binary64) (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im))) #s(literal -1 binary64))
(/.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(pow.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(log.f64 im)
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) im)))
(exp.f64 (log.f64 (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(neg.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))
(/.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 #s(literal -1 binary64) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal 1 binary64)))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 im) #s(literal 1/2 binary64)) (pow.f64 (log.f64 im) #s(literal 1/2 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(+.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(-.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 1 binary64))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 27 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 27 binary64))) #s(literal 1 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) #s(literal 1 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) #s(literal 1 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 27 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 1 binary64))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(log.f64 #s(literal 1/10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(+.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(log.f64 #s(literal 10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(exp.f64 (log.f64 (log.f64 #s(literal 10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 0 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (exp.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 im)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 im) (log.f64 im)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 im) (log.f64 (/.f64 #s(literal 1 binary64) im))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) im))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 im)) (*.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im))))
(*.f64 (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (log.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (log.f64 im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (log.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (log.f64 im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 im)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (log.f64 im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 #s(literal 10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(exp.f64 (log.f64 (log.f64 #s(literal 10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(exp.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (log.f64 im) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 im) (log.f64 im)) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))))
(+.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(*.f64 (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(+.f64 (log.f64 (log.f64 im)) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (log.f64 (log.f64 im)))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))))
(+.f64 (log.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (log.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(+.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #s(literal -1 binary64)))
(+.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (log.f64 (log.f64 im)))
(+.f64 (*.f64 #s(literal -1 binary64) (log.f64 (log.f64 #s(literal 10 binary64)))) (log.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(-.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(-.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 im))))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 im)) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(fma.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (log.f64 (exp.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (neg.f64 (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (neg.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1 binary64)) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (log.f64 (exp.f64 #s(literal -1 binary64))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(+.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 im))))
(+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(+.f64 (log.f64 #s(literal -1 binary64)) (+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(+.f64 (log.f64 #s(literal -1 binary64)) (-.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 im))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 (log.f64 #s(literal 10 binary64))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 im))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(-.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (log.f64 im)))
(-.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 im))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal -1 binary64)))
(-.f64 (/.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))) (/.f64 (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (/.f64 (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(fma.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64))))
(fma.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64) (log.f64 (log.f64 #s(literal 10 binary64))))
(fma.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64) (neg.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(fma.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))) #s(literal 0 binary64))
(fma.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal 0 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))) #s(literal 3 binary64))) (+.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (+.f64 (*.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))) (-.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im))))) (+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 (/.f64 #s(literal 1 binary64) im)))))
(*.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 1 binary64))
(*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 #s(literal 3 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 3/2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 3/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3/2 binary64)) #s(literal 2 binary64)))
(exp.f64 (+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64))))))
(exp.f64 (+.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(exp.f64 (+.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3/2 binary64)) (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3/2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 9 binary64)) (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 6 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 6 binary64)) (*.f64 #s(literal 3 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64))))))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) #s(literal 0 binary64))
(neg.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(neg.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 27 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 3/2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 #s(literal 3 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -6 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) (pow.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64)) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 5 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 9 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 18 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 12 binary64)))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 1 binary64)))
(exp.f64 (+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 6 binary64)) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 4 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))

simplify170.0ms (2.6%)

Algorithm
1×egg-herbie
Rules
2564×fnmadd-define
2140×fma-define
2120×fma-lowering-fma.f32
2120×fma-lowering-fma.f64
1276×sum3-define
Iterations

Useful iterations: 3 (0.0ms)

IterNodesCost
045972
186928
2153928
3372912
41095912
52775912
65834912
08279912
Stop Event
1×iter limit
1×node limit
Counts
132 → 132
Calls
Call 1
Inputs
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (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 im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
Outputs
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow (log 1/10) 3)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log 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.f64 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)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(* -1 (log (/ (log 10) (log im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))

eval573.0ms (8.7%)

Compiler

Compiled 37651 to 4139 computations (89% saved)

prune224.0ms (3.4%)

Pruning

20 alts after pruning (12 fresh and 8 done)

PrunedKeptTotal
New2229102239
Fresh325
Picked235
Done055
Total2234202254
Accuracy
100.0%
Counts
2254 → 20
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶72.4%
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
71.7%
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
▶97.3%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
51.3%
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
72.4%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64)))
72.9%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (*.f64 (log.f64 im) (log.f64 im)) #s(literal -1/2 binary64)))
✓97.6%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓51.5%
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓97.7%
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓97.8%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓97.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
71.9%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (exp.f64 (log.f64 (log.f64 im)))))
97.6%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
▶97.3%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
98.0%
(*.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
▶98.1%
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
▶71.9%
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
Compiler

Compiled 374 to 314 computations (16% saved)

simplify173.0ms (2.6%)

Algorithm
1×egg-herbie
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓cost-diff0
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))
✓cost-diff12928
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓cost-diff0
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
✓cost-diff12800
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 im))
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓cost-diff256
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓cost-diff128
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
✓cost-diff19392
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
✓cost-diff19456
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
Rules
2872×*-lowering-*.f32
2872×*-lowering-*.f64
1588×/-lowering-/.f32
1588×/-lowering-/.f64
1524×sum3-define
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
025133
149128
2106114
3372114
41136114
52396114
63738114
77792114
08139114
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(neg (/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im))))
(/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im)))
(pow (log 1/10) 2)
(log 1/10)
1/10
2
(/ (pow (log 1/10) 3) (log im))
(pow (log 1/10) 3)
3
(log im)
im
(* (/ 1 (log 10)) (log im))
(/ 1 (log 10))
1
(log 10)
10
(log im)
im
(/ (/ 1 (log 10)) (/ 1 (log im)))
(/ 1 (log 10))
1
(log 10)
10
(/ 1 (log im))
(log im)
im
(exp (log (/ (log im) (log 10))))
(log (/ (log im) (log 10)))
(/ (log im) (log 10))
(log im)
im
(log 10)
10
(pow (pow (/ (log 10) (log im)) -1/2) 2)
(pow (/ (log 10) (log im)) -1/2)
(/ (log 10) (log im))
(log 10)
10
(log im)
im
-1/2
2
Outputs
(neg (/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im))))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(pow (log 1/10) 2)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(log 1/10)
(log.f64 #s(literal 1/10 binary64))
1/10
#s(literal 1/10 binary64)
2
#s(literal 2 binary64)
(/ (pow (log 1/10) 3) (log im))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))
(pow (log 1/10) 3)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
3
#s(literal 3 binary64)
(log im)
(log.f64 im)
im
(* (/ 1 (log 10)) (log im))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ 1 (log 10))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
1
#s(literal 1 binary64)
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(log im)
(log.f64 im)
im
(/ (/ 1 (log 10)) (/ 1 (log im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ 1 (log 10))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
1
#s(literal 1 binary64)
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(log im)
(log.f64 im)
im
(exp (log (/ (log im) (log 10))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log (/ (log im) (log 10)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
im
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(pow (pow (/ (log 10) (log im)) -1/2) 2)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(pow (/ (log 10) (log im)) -1/2)
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log 10)
(log.f64 #s(literal 10 binary64))
10
#s(literal 10 binary64)
(log im)
(log.f64 im)
im
-1/2
#s(literal -1/2 binary64)
2
#s(literal 2 binary64)

localize163.0ms (2.5%)

Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.9%
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))
✓accuracy99.5%
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
✓accuracy99.2%
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.9%
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
✓accuracy99.3%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓accuracy98.7%
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓accuracy99.6%
(/.f64 #s(literal 1 binary64) (log.f64 im))
✓accuracy98.8%
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓accuracy98.8%
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓accuracy99.4%
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
✓accuracy98.8%
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy98.2%
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
Results
81.0ms189×0valid
23.0ms67×0invalid
Compiler

Compiled 146 to 27 computations (81.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 65.0ms
ival-pow: 20.0ms (30.6% of total)
ival-log: 16.0ms (24.5% of total)
ival-div: 12.0ms (18.4% of total)
ival-neg: 5.0ms (7.6% of total)
ival-mult: 4.0ms (6.1% of total)
...c/correct-round.rkt:119:19: 4.0ms (6.1% of total)
ival-exp: 3.0ms (4.6% of total)
const: 1.0ms (1.5% of total)
backward-pass: 0.0ms (0% of total)

series108.0ms (1.7%)

Counts
17 → 144
Calls
Call 1
Inputs
#<alt (/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im)))>
#<alt (neg (/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im))))>
#<alt (pow (log 1/10) 2)>
#<alt (log 1/10)>
#<alt (* (/ 1 (log 10)) (log im))>
#<alt (/ 1 (log 10))>
#<alt (log 10)>
#<alt (log im)>
#<alt (/ (/ 1 (log 10)) (/ 1 (log im)))>
#<alt (/ 1 (log im))>
#<alt (exp (log (/ (log im) (log 10))))>
#<alt (log (/ (log im) (log 10)))>
#<alt (/ (log im) (log 10))>
#<alt (pow (pow (/ (log 10) (log im)) -1/2) 2)>
#<alt (pow (/ (log 10) (log im)) -1/2)>
#<alt (/ (log 10) (log im))>
#<alt (pow (log 1/10) 3)>
Outputs
#<alt (/ (log im) (log 1/10))>
#<alt (/ (log im) (log 1/10))>
#<alt (/ (log im) (log 1/10))>
#<alt (/ (log im) (log 1/10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 1/10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 1/10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 1/10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 1/10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))>
#<alt (* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))>
#<alt (* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))>
#<alt (* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (log (/ (log im) (log 10)))>
#<alt (log (/ (log im) (log 10)))>
#<alt (log (/ (log im) (log 10)))>
#<alt (log (/ (log im) (log 10)))>
#<alt (log (* -1 (/ (log (/ 1 im)) (log 10))))>
#<alt (log (* -1 (/ (log (/ 1 im)) (log 10))))>
#<alt (log (* -1 (/ (log (/ 1 im)) (log 10))))>
#<alt (log (* -1 (/ (log (/ 1 im)) (log 10))))>
#<alt (log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (sqrt (/ (log im) (log 10)))>
#<alt (sqrt (/ (log im) (log 10)))>
#<alt (sqrt (/ (log im) (log 10)))>
#<alt (sqrt (/ (log im) (log 10)))>
#<alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))>
#<alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))>
#<alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))>
#<alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))>
#<alt (sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
Calls

36 calls:

TimeVariablePointExpression
68.0ms
im
@0
(log (/ (log im) (log 10)))
18.0ms
im
@-inf
(log (/ (log im) (log 10)))
18.0ms
im
@inf
(log (/ (log im) (log 10)))
1.0ms
im
@0
(pow (/ (log 10) (log im)) -1/2)
0.0ms
im
@inf
(pow (/ (log 10) (log im)) -1/2)

rewrite74.0ms (1.1%)

Algorithm
1×batch-egg-rewrite
Rules
298×/-lowering-/.f32
298×/-lowering-/.f64
292×*-lowering-*.f32
292×*-lowering-*.f64
80×pow-lowering-pow.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
02588
111378
056678
Stop Event
1×iter limit
1×iter limit
1×iter limit
1×unsound
Counts
17 → 325
Calls
Call 1
Inputs
(/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im)))
(neg (/ (pow (log 1/10) 2) (/ (pow (log 1/10) 3) (log im))))
(pow (log 1/10) 2)
(log 1/10)
(* (/ 1 (log 10)) (log im))
(/ 1 (log 10))
(log 10)
(log im)
(/ (/ 1 (log 10)) (/ 1 (log im)))
(/ 1 (log im))
(exp (log (/ (log im) (log 10))))
(log (/ (log im) (log 10)))
(/ (log im) (log 10))
(pow (pow (/ (log 10) (log im)) -1/2) 2)
(pow (/ (log 10) (log im)) -1/2)
(/ (log 10) (log im))
(pow (log 1/10) 3)
Outputs
(neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))))
(*.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (log.f64 im))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))
(neg.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))) (*.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))) (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))))
(*.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) (log.f64 im))
(*.f64 (*.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))) (log.f64 im))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (log.f64 im))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 2 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(log.f64 #s(literal 1/10 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(exp.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(log.f64 #s(literal 10 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(log.f64 im)
(/.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(exp.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(pow.f64 (log.f64 im) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(exp.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (log.f64 (log.f64 im)) (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (log.f64 im)) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (log.f64 im)))
(-.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (+.f64 (*.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 im))) (+.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64)))))))
(/.f64 (-.f64 (*.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 im))) (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (log.f64 #s(literal 10 binary64))))) (+.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64)))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(exp.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(exp.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(exp.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(exp.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal 1 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/4 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1/2 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (*.f64 #s(literal 3 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 3/2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 3 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3/2 binary64)))

simplify128.0ms (2%)

Algorithm
1×egg-herbie
Rules
1276×fnmadd-define
898×fma-define
814×sum3-define
776×fmsub-define
766×fnmsub-define
Iterations

Useful iterations: 4 (0.0ms)

IterNodesCost
0451012
184964
2139952
3292952
4733948
51595948
62876948
74068948
84778948
94818948
104837948
114845948
04845948
Stop Event
1×iter limit
1×saturated
Counts
144 → 144
Calls
Call 1
Inputs
(/ (log im) (log 1/10))
(/ (log im) (log 1/10))
(/ (log im) (log 1/10))
(/ (log im) (log 1/10))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log (/ (log im) (log 10)))
(log (/ (log im) (log 10)))
(log (/ (log im) (log 10)))
(log (/ (log im) (log 10)))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(sqrt (/ (log im) (log 10)))
(sqrt (/ (log im) (log 10)))
(sqrt (/ (log im) (log 10)))
(sqrt (/ (log im) (log 10)))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
Outputs
(/ (log im) (log 1/10))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(/ (log im) (log 1/10))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(/ (log im) (log 1/10))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(/ (log im) (log 1/10))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 1/10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (+ (* -1 (/ (log (/ -1 im)) (log 1/10))) (/ (log -1) (log 1/10))))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log 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.f64 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)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(log (/ (log im) (log 10)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (/ (log im) (log 10)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (/ (log im) (log 10)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (/ (log im) (log 10)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (* -1 (/ (log (/ 1 im)) (log 10))))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(log (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(log.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(sqrt (/ (log im) (log 10)))
(sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (log im) (log 10)))
(sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (log im) (log 10)))
(sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (log im) (log 10)))
(sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))
(sqrt.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))

eval67.0ms (1%)

Compiler

Compiled 6387 to 746 computations (88.3% saved)

prune52.0ms (0.8%)

Pruning

21 alts after pruning (9 fresh and 12 done)

PrunedKeptTotal
New5925597
Fresh347
Picked145
Done088
Total59621617
Accuracy
100.0%
Counts
617 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.4%
(pow.f64 (pow.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
72.4%
(pow.f64 (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
71.7%
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
✓97.3%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
71.9%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
51.3%
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
✓97.6%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓51.5%
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓97.7%
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓97.8%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓97.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
71.9%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (exp.f64 (log.f64 (log.f64 im)))))
97.6%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
97.3%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
✓97.3%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
98.2%
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
✓98.1%
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
✓71.9%
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
Compiler

Compiled 602 to 302 computations (49.8% saved)

regimes73.0ms (1.1%)

Counts
33 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (exp.f64 (log.f64 (log.f64 im)))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (*.f64 (log.f64 im) (log.f64 im)) #s(literal -1/2 binary64)))
(pow.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (log.f64 im))))
(*.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 im) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal -1/2 binary64)))
Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

11.0ms
im
9.0ms
(*.f64 im im)
9.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
9.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
9.0ms
re
Results
AccuracySegmentsBranch
99.1%1re
99.1%1im
99.1%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
99.1%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
99.1%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.1%1(+.f64 (*.f64 re re) (*.f64 im im))
99.1%1(*.f64 re re)
99.1%1(*.f64 im im)
Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes23.0ms (0.3%)

Accuracy

Total -30.6b remaining (-2170.6%)

Threshold costs -30.6b (-2170.6%)

Counts
14 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (+.f64 (*.f64 re re) (*.f64 im im)))))
Outputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
Calls

5 calls:

5.0ms
re
4.0ms
im
4.0ms
(*.f64 im im)
4.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
4.0ms
(*.f64 re re)
Results
AccuracySegmentsBranch
97.8%1im
97.8%1(+.f64 (*.f64 re re) (*.f64 im im))
97.8%1(*.f64 re re)
97.8%1(*.f64 im im)
97.8%1re
Compiler

Compiled 25 to 15 computations (40% saved)

simplify7.0ms (0.1%)

Algorithm
1×egg-herbie
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0912
Stop Event
1×saturated
Calls
Call 1
Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))

soundness229.0ms (3.5%)

Rules
3598×*-lowering-*.f32
3598×*-lowering-*.f64
2272×+-lowering-+.f64
2272×+-lowering-+.f32
1776×sum4-define
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02683088
18162954
227342938
370332938
080252938
0107
1137
2157
0157
Stop Event
1×fuel
1×iter limit
1×saturated
1×iter limit
1×node limit
Compiler

Compiled 30 to 22 computations (26.7% saved)

preprocess30.0ms (0.5%)

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 164 to 122 computations (25.6% saved)

end0.0ms (0%)

Profiling

Loading profile data...