Numeric.SpecFunctions:incompleteGamma from math-functions-0.1.5.2, A

Time bar (total: 4.1s)

start0.0ms (0%)

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

analyze2.0ms (0%)

Memory
2.6MiB live, 2.6MiB allocated; 0ms collecting garbage
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.8%0.2%0%0%0%0
0%0%99.8%0.2%0%0%0%1
0%0%99.8%0.2%0%0%0%2
0%0%49.9%0.2%0%49.9%0%3
0%0%49.9%0.2%0%49.9%0%4
100%25%0%0.2%0%74.9%0%5
Compiler

Compiled 13 to 12 computations (7.7% saved)

sample1.2s (28.4%)

Memory
38.2MiB live, 1 227.1MiB allocated; 172ms collecting garbage
Samples
820.0ms8 255×0valid
0.0ms1×1valid
Precisions
Click to see histograms. Total time spent on operations: 471.0ms
ival-log: 315.0ms (66.9% of total)
ival-sub!: 80.0ms (17% of total)
ival-mult!: 56.0ms (11.9% of total)
ival-add!: 18.0ms (3.8% of total)
adjust: 2.0ms (0.4% of total)
Bogosity

explain121.0ms (3%)

Memory
-20.8MiB live, 265.5MiB allocated; 32ms collecting garbage
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
00-0-(*.f64 x (log.f64 y))
00-0-(log.f64 t)
00-0-(log.f64 y)
00-0-t
00-0-(-.f64 (*.f64 x (log.f64 y)) y)
00-0-z
00-0-y
00-0-(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
00-0-(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
00-0-x
Confusion
Predicted +Predicted -
+00
-0256
Precision
0/0
Recall
0/0
Confusion?
Predicted +Predicted MaybePredicted -
+000
-00256
Precision?
0/0
Recall?
0/0
Freqs
test
numberfreq
0256
Total Confusion?
Predicted +Predicted MaybePredicted -
+000
-001
Precision?
0/0
Recall?
0/0
Samples
39.0ms512×0valid
Compiler

Compiled 89 to 34 computations (61.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 17.0ms
ival-log: 11.0ms (63.5% of total)
ival-mult!: 3.0ms (17.3% of total)
ival-sub!: 2.0ms (11.5% of total)
ival-add!: 1.0ms (5.8% of total)
adjust: 0.0ms (0% of total)

preprocess28.0ms (0.7%)

Memory
-7.2MiB live, 39.4MiB allocated; 3ms collecting garbage
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
055179
1122179
2222177
3358177
4644177
5891177
61208177
71471177
81521177
Stop Event
1×saturated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Compiler

Compiled 22 to 20 computations (9.1% saved)

series214.0ms (5.2%)

Memory
-3.4MiB live, 430.5MiB allocated; 101ms collecting garbage
Counts
10 → 53
Calls
Call 1
Inputs
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
(-.f64 (*.f64 x (log.f64 y)) y)
(*.f64 x (log.f64 y))
x
(log.f64 y)
y
z
(log.f64 t)
t
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* x (log y)) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* x (log y)) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* x (log y)) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
Calls

12 calls:

TimeVariablePointExpression
70.0ms
t
@0
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* x (log y)) x (log y) y z (log t) t)
48.0ms
x
@0
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* x (log y)) x (log y) y z (log t) t)
16.0ms
y
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* x (log y)) x (log y) y z (log t) t)
16.0ms
t
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* x (log y)) x (log y) y z (log t) t)
13.0ms
t
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* x (log y)) x (log y) y z (log t) t)

rewrite167.0ms (4.1%)

Memory
3.8MiB live, 291.2MiB allocated; 16ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0188993
0196934
11056900
08320889
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
63 → 110
Calls
Call 1
Inputs
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
(-.f64 (*.f64 x (log.f64 y)) y)
(*.f64 x (log.f64 y))
x
(log.f64 y)
y
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* x (log y)) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* x (log y)) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* x (log y)) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
Outputs
(/.f64 (-.f64 (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)) (*.f64 z z)) (+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (*.f64 (-.f64 z (log.f64 t)) (-.f64 z (log.f64 t)))) (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64))) (-.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))
(/.f64 (-.f64 (pow.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (fma.f64 z z (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64)) (pow.f64 (-.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 (-.f64 z (log.f64 t)) (-.f64 z (log.f64 t)) (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t))))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (*.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 y z)) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (*.f64 (+.f64 z y) (-.f64 y z)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 y z)) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (*.f64 (+.f64 z y) (-.f64 y z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))))
(/.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(+.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(+.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
(+.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (fma.f64 (log.f64 y) x (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 z y))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (*.f64 z z)) (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (fma.f64 (log.f64 y) x (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 z y)))))
(-.f64 (/.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)) (/.f64 (*.f64 z z) (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 (log.f64 y) x (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (fma.f64 (log.f64 y) x (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 z y))))))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)
(-.f64 (*.f64 (log.f64 y) x) (+.f64 z y))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 y y))) (neg.f64 (fma.f64 (log.f64 y) x y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (*.f64 (log.f64 y) x) y)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 y y)) (fma.f64 (log.f64 y) x y))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (*.f64 (log.f64 y) x) y))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 (log.f64 y) x y)) (/.f64 (*.f64 y y) (fma.f64 (log.f64 y) x y)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (*.f64 (log.f64 y) x) y)))) (/.f64 (pow.f64 y #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (*.f64 (log.f64 y) x) y)))))
(-.f64 (*.f64 (log.f64 y) x) y)
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
x
(log.f64 y)
y
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (+.f64 z y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (- (* x (log y)) y) (neg.f64 y))
#s(approx (- (* x (log y)) y) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* x (log y)) (*.f64 (log.f64 y) x))
#s(approx x x)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (log.f64 y) (/.f64 (+.f64 z y) x)) x))
#s(approx (- (* x (log y)) y) (*.f64 (log.f64 y) x))
#s(approx (- (* x (log y)) y) (*.f64 (-.f64 (log.f64 y) (/.f64 y x)) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 (log.f64 y)) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 x) (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (+.f64 z y) x))))
#s(approx (- (* x (log y)) y) (*.f64 (neg.f64 x) (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 y x))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z))
#s(approx (- (* x (log y)) y) (fma.f64 (log.f64 y) x (neg.f64 y)))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 y)) x (log.f64 t)) y) (-.f64 (/.f64 z y) #s(literal -1 binary64))) y))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) (/.f64 z y)) y))
#s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y))
#s(approx (* x (log y)) (*.f64 (neg.f64 x) (neg.f64 (log.f64 y))))
#s(approx (log y) (*.f64 #s(literal 1 binary64) (log.f64 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y)) (neg.f64 y)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x) z) y)) (neg.f64 y)))
#s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) y) #s(literal 1 binary64)) (neg.f64 y)))
#s(approx (* x (log y)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
#s(approx z z)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) (neg.f64 z)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)) (neg.f64 z)))
#s(approx (log t) (log.f64 t))
#s(approx t t)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (log t) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))

eval12.0ms (0.3%)

Memory
31.7MiB live, 31.7MiB allocated; 0ms collecting garbage
Compiler

Compiled 2 849 to 450 computations (84.2% saved)

prune11.0ms (0.3%)

Memory
-20.8MiB live, 26.5MiB allocated; 1ms collecting garbage
Pruning

15 alts after pruning (15 fresh and 0 done)

PrunedKeptTotal
New9715112
Fresh000
Picked101
Done000
Total9815113
Accuracy
100.0%
Counts
113 → 15
Alt Table
Click to see full alt table
StatusAccuracyProgram
24.5%
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))))
▶99.9%
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
88.5%
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
▶99.9%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))
82.5%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)) (log.f64 t))
▶41.7%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
46.6%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
▶36.3%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
75.7%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
65.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
70.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
82.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 y)) x (log.f64 t)) y) (-.f64 (/.f64 z y) #s(literal -1 binary64))) y))
31.2%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
35.7%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
▶25.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Compiler

Compiled 670 to 456 computations (31.9% saved)

series166.0ms (4.1%)

Memory
-10.4MiB live, 328.2MiB allocated; 26ms collecting garbage
Counts
21 → 105
Calls
Call 1
Inputs
(+.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
(-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)
(fma.f64 (log.f64 y) x (neg.f64 z))
(log.f64 y)
y
x
(neg.f64 z)
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
(neg.f64 y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x (log.f64 t))
(+.f64 z y)
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* x (log y)) z)))
#s(approx x #s(hole binary64 x))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (log t)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (log y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* x (+ (log y) (* -1 (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (neg y) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* -1 (* x (log (/ 1 y)))) z)))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ z y) #s(hole binary64 y))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (+ (* -1 z) (* x (log y)))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* x (log y)) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
Calls

12 calls:

TimeVariablePointExpression
34.0ms
y
@0
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (neg z)) y) (+ (* (log y) x) (neg z)) (log y) y x (neg z) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (log y) x) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (+ z y))
33.0ms
t
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (neg z)) y) (+ (* (log y) x) (neg z)) (log y) y x (neg z) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (log y) x) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (+ z y))
21.0ms
t
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (neg z)) y) (+ (* (log y) x) (neg z)) (log y) y x (neg z) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (log y) x) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (+ z y))
15.0ms
y
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (neg z)) y) (+ (* (log y) x) (neg z)) (log y) y x (neg z) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (log y) x) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (+ z y))
13.0ms
y
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (neg z)) y) (+ (* (log y) x) (neg z)) (log y) y x (neg z) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (log y) x) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (+ z y))

rewrite179.0ms (4.4%)

Memory
44.7MiB live, 318.9MiB allocated; 22ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02752070
02961922
114031915
085311905
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
126 → 274
Calls
Call 1
Inputs
(+.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
(-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)
(fma.f64 (log.f64 y) x (neg.f64 z))
(log.f64 y)
y
x
(neg.f64 z)
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
(neg.f64 y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x (log.f64 t))
(+.f64 z y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* x (log y)) z)))
#s(approx x #s(hole binary64 x))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (log t)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (log y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* x (+ (log y) (* -1 (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (neg y) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* -1 (* x (log (/ 1 y)))) z)))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ z y) #s(hole binary64 y))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (+ (* -1 z) (* x (log y)))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (- (+ (* (log y) x) (neg z)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (+ (* (log y) x) (neg z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* x (log y)) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
Outputs
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64))) (-.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (*.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))))
(+.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))))))
(+.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64))) (-.f64 (neg.f64 z) (-.f64 (*.f64 (log.f64 y) x) y)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (-.f64 (neg.f64 z) y) (-.f64 (neg.f64 z) y))) (-.f64 (*.f64 (log.f64 y) x) (-.f64 (neg.f64 z) y)))
(/.f64 (fma.f64 (pow.f64 z #s(literal 3 binary64)) #s(literal -1 binary64) (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (*.f64 (neg.f64 z) (-.f64 (*.f64 (log.f64 y) x) y)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (-.f64 (neg.f64 z) y) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (-.f64 (neg.f64 z) y) (-.f64 (neg.f64 z) y)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (neg.f64 z) y)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (*.f64 y y))) (neg.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (*.f64 y y)) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))))
(fma.f64 #s(literal -1 binary64) z (-.f64 (*.f64 (log.f64 y) x) y))
(fma.f64 z #s(literal -1 binary64) (-.f64 (*.f64 (log.f64 y) x) y))
(fma.f64 (log.f64 y) x (-.f64 (neg.f64 z) y))
(fma.f64 x (log.f64 y) (-.f64 (neg.f64 z) y))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (/.f64 (*.f64 y y) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))) (/.f64 (pow.f64 y #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) #s(literal 2 binary64)) (fma.f64 y y (*.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))))
(-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)
(+.f64 (neg.f64 z) (-.f64 (*.f64 (log.f64 y) x) y))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (neg.f64 z) y))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (neg.f64 x) (log.f64 y)))) (+.f64 (neg.f64 z) (*.f64 (neg.f64 x) (log.f64 y))))
(/.f64 (-.f64 (pow.f64 (neg.f64 z) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 x) (log.f64 y)) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (neg.f64 z) (*.f64 (neg.f64 x) (log.f64 y))))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (neg.f64 (-.f64 (neg.f64 z) (*.f64 (log.f64 y) x))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) (neg.f64 z))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 z #s(literal 3 binary64)) #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z z (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (neg.f64 z) (*.f64 (log.f64 y) x))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (neg.f64 z) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (*.f64 (log.f64 y) x) (neg.f64 z))))))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 (neg.f64 z) (*.f64 (log.f64 y) x)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 (*.f64 (log.f64 y) x) (neg.f64 z)))
(/.f64 (fma.f64 (pow.f64 z #s(literal 3 binary64)) #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (neg.f64 z) (*.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (neg.f64 z) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (*.f64 (log.f64 y) x) (neg.f64 z)))))
(fma.f64 #s(literal -1 binary64) z (*.f64 (log.f64 y) x))
(fma.f64 z #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (neg.f64 z))
(fma.f64 x (log.f64 y) (neg.f64 z))
(-.f64 (/.f64 (*.f64 z z) (-.f64 (neg.f64 z) (*.f64 (log.f64 y) x))) (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (neg.f64 z) (*.f64 (log.f64 y) x))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (neg.f64 z))) (/.f64 (*.f64 z z) (-.f64 (*.f64 (log.f64 y) x) (neg.f64 z))))
(-.f64 (neg.f64 z) (*.f64 (neg.f64 x) (log.f64 y)))
(+.f64 (/.f64 (pow.f64 (neg.f64 z) #s(literal 3 binary64)) (fma.f64 z z (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (neg.f64 z) (*.f64 (log.f64 y) x))))) (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (fma.f64 z z (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (neg.f64 z) (*.f64 (log.f64 y) x))))))
(+.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (*.f64 (log.f64 y) x) (neg.f64 z))))) (/.f64 (pow.f64 (neg.f64 z) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (*.f64 (log.f64 y) x) (neg.f64 z))))))
(+.f64 (neg.f64 z) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (neg.f64 z))
(log.f64 y)
y
x
(*.f64 #s(literal -1 binary64) z)
(*.f64 z #s(literal -1 binary64))
(neg.f64 z)
z
(log.f64 t)
t
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
(*.f64 #s(literal -1 binary64) y)
(*.f64 y #s(literal -1 binary64))
(neg.f64 y)
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 2 binary64))) (-.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 2 binary64)) (*.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))))
(+.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(literal 3 binary64)) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))))))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))))
(+.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))))))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
(+.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
(/.f64 (-.f64 (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)) (*.f64 z z)) (+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (-.f64 (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (*.f64 y y)) (+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (*.f64 (-.f64 z (log.f64 t)) (-.f64 z (log.f64 t)))) (+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64))) (-.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (log.f64 t) y) z) (-.f64 (-.f64 (log.f64 t) y) z))) (-.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z)))
(/.f64 (-.f64 (pow.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (fma.f64 z z (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
(/.f64 (-.f64 (pow.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (fma.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (fma.f64 y y (*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y))))
(/.f64 (-.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 3 binary64)) (pow.f64 (-.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (*.f64 (log.f64 y) x) y) #s(literal 2 binary64)) (fma.f64 (-.f64 z (log.f64 t)) (-.f64 z (log.f64 t)) (*.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t))))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (*.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (-.f64 (-.f64 (log.f64 t) y) z) (-.f64 (-.f64 (log.f64 t) y) z)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 y z)) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 z y)) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 y z)) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 z y)) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 y z)) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 z y)) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 y z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 z y)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))))
(/.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))))
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
(fma.f64 x (log.f64 y) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(+.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(+.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
(+.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (neg.f64 x) (log.f64 y)))) (+.f64 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 x) (log.f64 y)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (fma.f64 (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (neg.f64 x) (log.f64 y)) (*.f64 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (neg.f64 (log.f64 (/.f64 t (pow.f64 y x)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (log.f64 (/.f64 (pow.f64 y x) t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (log.f64 (/.f64 t (pow.f64 y x))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (log.f64 (/.f64 (pow.f64 y x) t)))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))))
(fma.f64 (log.f64 y) x (log.f64 t))
(fma.f64 x (log.f64 y) (log.f64 t))
(-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 (/.f64 t (pow.f64 y x)))) (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (log.f64 (/.f64 t (pow.f64 y x)))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (log.f64 (/.f64 (pow.f64 y x) t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 (/.f64 (pow.f64 y x) t))))
(-.f64 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y)))
(+.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x))))) (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x))))))
(+.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))))
(+.f64 (log.f64 t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(log.f64 (*.f64 t (pow.f64 y x)))
(log.f64 (*.f64 (pow.f64 y x) t))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (*.f64 z z))) (neg.f64 (-.f64 y z)))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 y y))) (neg.f64 (-.f64 z y)))
(/.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (-.f64 y z))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (-.f64 z y))
(/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
(-.f64 (/.f64 (*.f64 y y) (-.f64 y z)) (/.f64 (*.f64 z z) (-.f64 y z)))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z y)) (/.f64 (*.f64 y y) (-.f64 z y)))
(+.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 y z)))))
(+.f64 (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(+.f64 z y)
(+.f64 y z)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (+.f64 z y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (- (+ (* (log y) x) (neg z)) y) (neg.f64 (+.f64 z y)))
#s(approx (- (+ (* (log y) x) (neg z)) y) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (+ (* (log y) x) (neg z)) (neg.f64 z))
#s(approx (+ (* (log y) x) (neg z)) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx x x)
#s(approx (* (log y) x) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (+ (* (log y) x) (log t)) (log.f64 t))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (log.f64 t)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (+.f64 z y) x) #s(literal -1 binary64) (log.f64 y)) x))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (fma.f64 (/.f64 (+.f64 z y) x) #s(literal -1 binary64) (log.f64 y)) x))
#s(approx (+ (* (log y) x) (neg z)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) (neg z)) (*.f64 (fma.f64 (/.f64 z x) #s(literal -1 binary64) (log.f64 y)) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (+.f64 (/.f64 (log.f64 t) x) (log.f64 y)) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 (*.f64 (fma.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (+.f64 z y) x)) x)))
#s(approx (- (+ (* (log y) x) (neg z)) y) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (+.f64 z y) x)) x)))
#s(approx (+ (* (log y) x) (neg z)) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 z x)) x)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 (*.f64 (fma.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (log t)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 t) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z))
#s(approx (- (+ (* (log y) x) (neg z)) y) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx (- (+ (* (log y) x) (neg z)) y) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (neg y) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (+ z y) z)
#s(approx (+ z y) (+.f64 z y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (- (+ (* (log y) x) (neg z)) y) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (-.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (+ (* (log y) x) (neg z)) (-.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) z))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (* (log y) x) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)))
#s(approx (+ z y) y)
#s(approx (+ z y) (*.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (neg z)) (-.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x) z))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (* (log y) x) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)))
#s(approx (+ z y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
#s(approx (- (+ (* (log y) x) (neg z)) y) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (- (+ (* (log y) x) (neg z)) y) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
#s(approx (+ (* (log y) x) (neg z)) (fma.f64 (log.f64 y) x (neg.f64 z)))
#s(approx (neg z) (neg.f64 z))
#s(approx z z)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (+ (* (log y) x) (neg z)) y) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (-.f64 (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (+ (* (log y) x) (neg z)) (*.f64 (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) #s(literal 1 binary64)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (+ z y) (*.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (neg z)) y) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (neg z)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ z y) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 y) z) #s(literal 1 binary64))))
#s(approx (log t) (log.f64 t))
#s(approx t t)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (log t) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (+ (* (log y) x) (log t)) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))))

eval36.0ms (0.9%)

Memory
-16.9MiB live, 88.0MiB allocated; 8ms collecting garbage
Compiler

Compiled 8 784 to 1 054 computations (88% saved)

prune14.0ms (0.3%)

Memory
-9.6MiB live, 37.3MiB allocated; 2ms collecting garbage
Pruning

13 alts after pruning (10 fresh and 3 done)

PrunedKeptTotal
New2956301
Fresh6410
Picked235
Done000
Total30313316
Accuracy
100.0%
Counts
316 → 13
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
24.5%
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
▶88.9%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
70.3%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
88.5%
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
▶82.5%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)) (log.f64 t))
✓41.7%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
▶46.6%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
✓36.3%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
31.2%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
▶35.7%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
82.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 y)) x (log.f64 t)) y) (-.f64 (/.f64 z y) #s(literal -1 binary64))) y))
✓25.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Compiler

Compiled 530 to 353 computations (33.4% saved)

series173.0ms (4.2%)

Memory
4.0MiB live, 433.0MiB allocated; 42ms collecting garbage
Counts
25 → 158
Calls
Call 1
Inputs
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
(log.f64 y)
y
x
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) y)
(log.f64 t)
t
z
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
(neg.f64 z)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(+.f64 z y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z))
(*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)
(-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z))
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64))
(/.f64 (log.f64 y) z)
#s(literal -1 binary64)
(/.f64 y z)
Outputs
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (log t)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (log y)))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 (* z (+ 1 (/ y z)))) (* x (log y)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (+ 1 (/ y z)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) (+ 1 (/ y z)))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 -1))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* x (+ (* -1 (/ (+ 1 (/ y z)) x)) (/ (log y) z)))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (* x (- (/ (log y) z) (/ 1 x)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (+ (/ 1 x) (/ y (* x z))))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 y)) z)))
#s(approx (- (log t) y) #s(hole binary64 (log t)))
#s(approx (- (log t) y) #s(hole binary64 (+ (log t) (* -1 y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 y) (* z (- (/ (* x (log y)) z) 1)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (+ (* -1 (/ y z)) (/ (* x (log y)) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (/ y z) #s(hole binary64 (/ y z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ z y) #s(hole binary64 y))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* y (- (/ (* z (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)) y) 1))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (/ y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ 1 y) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (log t) z) y)))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (log t) y)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* z (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)) y)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1) y)) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (* x (log y)) y) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (+ (* -1 z) (* x (log y))) y) z)))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (/ (+ (* -1 z) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 -1))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (- (+ 1 (* -1 (/ (* x (log y)) z))) (* -1 (/ y z)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (* -1 (/ (- (* -1 (* x (log y))) (* -1 y)) z)) 1)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (log t) y)))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (* -1 (log (/ 1 t))) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (* -1 (log (/ 1 t))) y)))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) y)))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
Calls

12 calls:

TimeVariablePointExpression
18.0ms
z
@inf
((+ (* (log y) x) (- (- (log t) y) z)) (log y) y x (- (- (log t) y) z) (- (log t) y) (log t) t z (- (+ (* (log y) x) (log t)) (+ z y)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (* (log y) x) (+ z y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (+ (* x (/ (log y) z)) -1) (/ (log y) z) -1 (/ y z))
17.0ms
y
@-inf
((+ (* (log y) x) (- (- (log t) y) z)) (log y) y x (- (- (log t) y) z) (- (log t) y) (log t) t z (- (+ (* (log y) x) (log t)) (+ z y)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (* (log y) x) (+ z y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (+ (* x (/ (log y) z)) -1) (/ (log y) z) -1 (/ y z))
17.0ms
y
@inf
((+ (* (log y) x) (- (- (log t) y) z)) (log y) y x (- (- (log t) y) z) (- (log t) y) (log t) t z (- (+ (* (log y) x) (log t)) (+ z y)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (* (log y) x) (+ z y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (+ (* x (/ (log y) z)) -1) (/ (log y) z) -1 (/ y z))
15.0ms
t
@-inf
((+ (* (log y) x) (- (- (log t) y) z)) (log y) y x (- (- (log t) y) z) (- (log t) y) (log t) t z (- (+ (* (log y) x) (log t)) (+ z y)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (* (log y) x) (+ z y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (+ (* x (/ (log y) z)) -1) (/ (log y) z) -1 (/ y z))
15.0ms
t
@0
((+ (* (log y) x) (- (- (log t) y) z)) (log y) y x (- (- (log t) y) z) (- (log t) y) (log t) t z (- (+ (* (log y) x) (log t)) (+ z y)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (+ (* (log y) x) (log t)) (+ z y)) (+ (* (log y) x) (log t)) (* (log y) x) (+ z y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (+ (* x (/ (log y) z)) -1) (/ (log y) z) -1 (/ y z))

rewrite220.0ms (5.4%)

Memory
24.5MiB live, 384.6MiB allocated; 48ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
04263312
04553102
121823064
0101203039
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
183 → 338
Calls
Call 1
Inputs
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
(log.f64 y)
y
x
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) y)
(log.f64 t)
t
z
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
(neg.f64 z)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(+.f64 z y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z))
(*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)
(-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z))
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64))
(/.f64 (log.f64 y) z)
#s(literal -1 binary64)
(/.f64 y z)
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (log t)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (log y)))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 (* z (+ 1 (/ y z)))) (* x (log y)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (+ 1 (/ y z)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) (+ 1 (/ y z)))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 -1))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* x (+ (* -1 (/ (+ 1 (/ y z)) x)) (/ (log y) z)))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (* x (- (/ (log y) z) (/ 1 x)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (+ (/ 1 x) (/ y (* x z))))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 y)) z)))
#s(approx (- (log t) y) #s(hole binary64 (log t)))
#s(approx (- (log t) y) #s(hole binary64 (+ (log t) (* -1 y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 y) (* z (- (/ (* x (log y)) z) 1)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (+ (* -1 (/ y z)) (/ (* x (log y)) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (/ y z) #s(hole binary64 (/ y z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ z y) #s(hole binary64 y))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* y (- (/ (* z (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)) y) 1))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (/ y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ 1 y) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (log t) z) y)))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (log t) y)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* z (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)) y)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1) y)) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (* x (log y)) y) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (+ (* -1 z) (* x (log y))) y) z)))
#s(approx (+ (* x (/ (log y) z)) -1) #s(hole binary64 (/ (+ (* -1 z) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 -1))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (- (+ 1 (* -1 (/ (* x (log y)) z))) (* -1 (/ y z)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (* -1 (/ (- (* -1 (* x (log y))) (* -1 y)) z)) 1)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (log t) y)))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (* -1 (log (/ 1 t))) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (* -1 (log (/ 1 t))) y)))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) (+ y z))))
#s(approx (- (log t) y) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) y)))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
Outputs
(/.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (log.f64 t) y) z) (*.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (*.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 z y)) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 y z)) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 (pow.f64 y x) t)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 z y)) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 y z)) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (log.f64 (/.f64 t (pow.f64 y x))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 z y)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 y z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 z y)) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 (*.f64 z z) (*.f64 y y)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 z y)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 y z)) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (-.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64))) (-.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z)))
(/.f64 (-.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z)))))
(/.f64 (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t)))))
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
(fma.f64 x (log.f64 y) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))) (/.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))))
(-.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (log.f64 t)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))))))
(-.f64 (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)) z)
(-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y)
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(+.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))))) (/.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 (-.f64 (log.f64 t) y) z) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))))))
(+.f64 (/.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))))))
(+.f64 (-.f64 (-.f64 (log.f64 t) y) z) (*.f64 (log.f64 y) x))
(+.f64 (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) (log.f64 t))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (-.f64 (log.f64 t) y) z))
(+.f64 (log.f64 t) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
(log.f64 y)
y
x
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (+.f64 (-.f64 (log.f64 t) y) z)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (+.f64 (log.f64 t) (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (log.f64 t) y) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 t) (log.f64 t) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (log.f64 t) (+.f64 z y))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (*.f64 z z)) (+.f64 (-.f64 (log.f64 t) y) z))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (+.f64 (log.f64 t) (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (log.f64 t) y) z))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (log.f64 t) (+.f64 z y)))))
(-.f64 (/.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (+.f64 (-.f64 (log.f64 t) y) z)) (/.f64 (*.f64 z z) (+.f64 (-.f64 (log.f64 t) y) z)))
(-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (log.f64 t) (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (+.f64 (log.f64 t) (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (log.f64 t) y) z)))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (+.f64 (pow.f64 (-.f64 (log.f64 t) y) #s(literal 2 binary64)) (fma.f64 z z (*.f64 (-.f64 (log.f64 t) y) z)))))
(-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (log.f64 t) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 (log.f64 t) (+.f64 z y))))))
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) (+.f64 z y))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 y y))) (neg.f64 (+.f64 (log.f64 t) y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 t) (log.f64 t) (fma.f64 y y (*.f64 (log.f64 t) y)))))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 y y)) (+.f64 (log.f64 t) y))
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (fma.f64 y y (*.f64 (log.f64 t) y))))
(-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (log.f64 t) y)) (/.f64 (*.f64 y y) (+.f64 (log.f64 t) y)))
(-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (fma.f64 y y (*.f64 (log.f64 t) y)))) (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 (log.f64 t) (log.f64 t) (fma.f64 y y (*.f64 (log.f64 t) y)))))
(-.f64 (log.f64 t) y)
(log.f64 t)
t
z
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
(*.f64 #s(literal -1 binary64) z)
(*.f64 z #s(literal -1 binary64))
(neg.f64 z)
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 2 binary64)) (*.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))))
(+.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(literal 3 binary64)) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))))))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
(+.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (pow.f64 (+.f64 z y) #s(literal 2 binary64))) (+.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y)))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (pow.f64 (+.f64 z y) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y)))))
(-.f64 (/.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (+.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (+.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))))
(-.f64 (/.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))))) (/.f64 (pow.f64 (+.f64 z y) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (+.f64 (pow.f64 (+.f64 z y) #s(literal 2 binary64)) (*.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))))))
(-.f64 (-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) z) y)
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 y y))) (neg.f64 (-.f64 z y)))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (*.f64 z z))) (neg.f64 (-.f64 y z)))
(/.f64 (neg.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (-.f64 z y))
(/.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (-.f64 y z))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
(/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y))))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z y)) (/.f64 (*.f64 y y) (-.f64 z y)))
(-.f64 (/.f64 (*.f64 y y) (-.f64 y z)) (/.f64 (*.f64 z z) (-.f64 y z)))
(+.f64 (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(+.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 y y (-.f64 (*.f64 z z) (*.f64 z y)))))
(+.f64 z y)
(+.f64 y z)
(/.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 3 binary64))) (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (*.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t)))))
(-.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))))
(+.f64 (/.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))))))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)) (log.f64 t))
(+.f64 (log.f64 t) #s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z))
(*.f64 (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))) z)
(*.f64 z (fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z))))
(/.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) (pow.f64 (-.f64 #s(literal -1 binary64) (/.f64 y z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 (*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y z)) (-.f64 #s(literal -1 binary64) (/.f64 y z))) (*.f64 (*.f64 (/.f64 (log.f64 y) z) x) (-.f64 #s(literal -1 binary64) (/.f64 y z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (pow.f64 (/.f64 y z) #s(literal 2 binary64)))) (neg.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 y z) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))))))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64)) (neg.f64 z)) (*.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64)) (neg.f64 y))) (*.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64)) (neg.f64 z)))
(/.f64 (-.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64)) z) (*.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64)) y)) (*.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64)) z))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal -1 binary64)) (neg.f64 z)) (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))) (neg.f64 y))) (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))) (neg.f64 z)))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal -1 binary64)) z) (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))) z))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (pow.f64 (/.f64 y z) #s(literal 2 binary64))) (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (/.f64 y z) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 y z) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z)))))
(fma.f64 (/.f64 (*.f64 #s(literal -1 binary64) x) z) (/.f64 (log.f64 y) #s(literal -1 binary64)) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) z) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 (/.f64 #s(literal -1 binary64) z) (/.f64 (*.f64 (log.f64 y) x) #s(literal -1 binary64)) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 (/.f64 (*.f64 #s(literal -1 binary64) x) #s(literal -1 binary64)) (/.f64 (log.f64 y) z) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) z) x) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 (/.f64 (log.f64 y) z) x (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(fma.f64 x (/.f64 (log.f64 y) z) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(-.f64 (/.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))) (/.f64 (pow.f64 (/.f64 y z) #s(literal 2 binary64)) (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 y z) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))))) (/.f64 (pow.f64 (/.f64 y z) #s(literal 3 binary64)) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 y z) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))))))
(-.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64)) (/.f64 y z))
(+.f64 (*.f64 (/.f64 (log.f64 y) z) x) (-.f64 #s(literal -1 binary64) (/.f64 y z)))
(/.f64 (+.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal -1 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64))))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64)))
(/.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal -1 binary64)) (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))))
(fma.f64 (/.f64 (*.f64 #s(literal -1 binary64) x) z) (/.f64 (log.f64 y) #s(literal -1 binary64)) #s(literal -1 binary64))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) z) #s(literal -1 binary64))
(fma.f64 (/.f64 #s(literal -1 binary64) z) (/.f64 (*.f64 (log.f64 y) x) #s(literal -1 binary64)) #s(literal -1 binary64))
(fma.f64 (/.f64 (*.f64 #s(literal -1 binary64) x) #s(literal -1 binary64)) (/.f64 (log.f64 y) z) #s(literal -1 binary64))
(fma.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64) #s(literal -1 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64))
(fma.f64 (/.f64 (log.f64 y) z) x #s(literal -1 binary64))
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64))
(-.f64 (/.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64))))
(+.f64 (/.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z))))) (/.f64 #s(literal -1 binary64) (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z))))))
(+.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal -1 binary64))
(+.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 y) z) x))
(*.f64 (/.f64 (log.f64 y) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) z))
(*.f64 (/.f64 #s(literal -1 binary64) z) (/.f64 (log.f64 y) #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 y) z))
(*.f64 (/.f64 (log.f64 y) z) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 (log.f64 y))) (neg.f64 (neg.f64 z)))
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 z))
(/.f64 (log.f64 y) z)
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 z)) (/.f64 (log.f64 y) (neg.f64 z)))
#s(literal -1 binary64)
(*.f64 (/.f64 y #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) z))
(*.f64 (/.f64 #s(literal -1 binary64) z) (/.f64 y #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 y z))
(*.f64 (/.f64 y z) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 y)) (neg.f64 (neg.f64 z)))
(/.f64 (neg.f64 y) (neg.f64 z))
(/.f64 y z)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z)))
#s(approx x x)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (+.f64 z y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (+ (* (log y) x) (log t)) (log.f64 t))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (log.f64 t)))
#s(approx (* (log y) x) (*.f64 (log.f64 y) x))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (neg.f64 z) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (fma.f64 (neg.f64 z) (+.f64 #s(literal 1 binary64) (/.f64 y z)) (*.f64 (log.f64 y) x)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (neg.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)) (/.f64 y z)))
#s(approx (+ (* x (/ (log y) z)) -1) #s(literal -1 binary64))
#s(approx (+ (* x (/ (log y) z)) -1) (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (fma.f64 (/.f64 (+.f64 z y) x) #s(literal -1 binary64) (log.f64 y)) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (+.f64 (/.f64 (log.f64 t) x) (log.f64 y)) x))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (log.f64 y) x))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (fma.f64 (/.f64 (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) z) x) #s(literal -1 binary64) (log.f64 y)) x))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (fma.f64 (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) x) #s(literal -1 binary64) (/.f64 (log.f64 y) z)) x))
#s(approx (+ (* x (/ (log y) z)) -1) (*.f64 (/.f64 (log.f64 y) z) x))
#s(approx (+ (* x (/ (log y) z)) -1) (*.f64 (-.f64 (/.f64 (log.f64 y) z) (pow.f64 x #s(literal -1 binary64))) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 (*.f64 (fma.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 (*.f64 (fma.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 (*.f64 (fma.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (+.f64 z y) x)) x)))
#s(approx (+ (* (log y) x) (log t)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 t) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (neg.f64 (*.f64 (fma.f64 z (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) x) (neg.f64 (log.f64 y))) x)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 y) z) #s(literal -1 binary64) (+.f64 (/.f64 (/.f64 y x) z) (pow.f64 x #s(literal -1 binary64)))) x)))
#s(approx (+ (* x (/ (log y) z)) -1) (neg.f64 (fma.f64 (/.f64 (neg.f64 (log.f64 y)) z) x #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z))
#s(approx (- (- (log t) y) z) (-.f64 (fma.f64 #s(literal -1 binary64) y (log.f64 t)) z))
#s(approx (- (log t) y) (log.f64 t))
#s(approx (- (log t) y) (fma.f64 #s(literal -1 binary64) y (log.f64 t)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z))
#s(approx (+ z y) z)
#s(approx (+ z y) (+.f64 z y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)) z))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (fma.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)) z (neg.f64 y)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (/.f64 (log.f64 y) z))
#s(approx (/ y z) (/.f64 y z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (- (- (log t) y) z) (neg.f64 y))
#s(approx (- (- (log t) y) z) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (- (log t) y) (neg.f64 y))
#s(approx (- (log t) y) (*.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 y))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))) (+.f64 (/.f64 z y) #s(literal 1 binary64))) y))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) (log.f64 t)))
#s(approx (* (log y) x) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (+ z y) y)
#s(approx (+ z y) (*.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (neg.f64 y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (-.f64 (*.f64 z (/.f64 (-.f64 (/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) z) #s(literal 1 binary64)) y)) #s(literal 1 binary64)) y))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (neg.f64 y) z))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (-.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (fma.f64 #s(literal 1 binary64) z (*.f64 y #s(literal 1 binary64)))) (*.f64 z y)) y))
#s(approx (+ (* x (/ (log y) z)) -1) (-.f64 (/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) z) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (neg.f64 (/.f64 (neg.f64 (log.f64 y)) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (- (- (log t) y) z) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (log.f64 t) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (log t) y) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (log.f64 t) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x) z) y) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (log.f64 t)))
#s(approx (* (log y) x) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x))
#s(approx (+ z y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (neg.f64 y) (fma.f64 (*.f64 z (/.f64 (-.f64 (*.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z)) #s(literal 1 binary64)) y)) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (neg.f64 y) (fma.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z)) #s(literal 1 binary64)) y) #s(literal -1 binary64) (pow.f64 z #s(literal -1 binary64)))))
#s(approx (+ (* x (/ (log y) z)) -1) (-.f64 (*.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z)) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) y))
#s(approx (- (- (log t) y) z) (-.f64 (fma.f64 #s(literal -1 binary64) z (log.f64 t)) y))
#s(approx z z)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (neg z) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (+.f64 (log.f64 t) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y) z))
#s(approx (+ (* x (/ (log y) z)) -1) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (- (log t) y) z) (neg.f64 z))
#s(approx (- (- (log t) y) z) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 z))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (+ z y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) z))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (neg.f64 z))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (-.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(literal -1 binary64))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (- (log t) y) z) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (log.f64 t) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (+ z y) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 y) z) #s(literal 1 binary64))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 (neg.f64 z) (fma.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z) #s(literal -1 binary64) #s(literal 1 binary64))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (neg.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))) #s(literal 1 binary64)))
#s(approx (- (- (log t) y) z) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (- (log t) y) (-.f64 (log.f64 t) y))
#s(approx (log t) (log.f64 t))
#s(approx t t)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (- (- (log t) y) z) (-.f64 (neg.f64 (neg.f64 (log.f64 t))) (+.f64 z y)))
#s(approx (- (log t) y) (-.f64 (neg.f64 (neg.f64 (log.f64 t))) y))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) (+.f64 z y)))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (- (- (log t) y) z) (-.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (- (log t) y) (-.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) y))
#s(approx (log t) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))) (+.f64 z y)))
#s(approx (+ (* (log y) x) (log t)) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) (log.f64 #s(literal -1 binary64))))

eval68.0ms (1.7%)

Memory
4.8MiB live, 113.6MiB allocated; 36ms collecting garbage
Compiler

Compiled 10 734 to 1 372 computations (87.2% saved)

prune14.0ms (0.3%)

Memory
-13.3MiB live, 34.2MiB allocated; 2ms collecting garbage
Pruning

14 alts after pruning (8 fresh and 6 done)

PrunedKeptTotal
New3483351
Fresh055
Picked235
Done033
Total35014364
Accuracy
100.0%
Counts
364 → 14
Alt Table
Click to see full alt table
StatusAccuracyProgram
64.8%
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
▶54.9%
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
▶24.5%
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
✓88.9%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
70.3%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
▶88.5%
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
✓41.7%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
▶32.4%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
✓46.6%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
✓36.3%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
▶31.2%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
✓35.7%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
82.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 y)) x (log.f64 t)) y) (-.f64 (/.f64 z y) #s(literal -1 binary64))) y))
✓25.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Compiler

Compiled 534 to 350 computations (34.5% saved)

series319.0ms (7.8%)

Memory
33.8MiB live, 599.4MiB allocated; 72ms collecting garbage
Counts
48 → 379
Calls
Call 1
Inputs
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
(-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z)
#s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)
(fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64))
(neg.f64 x)
x
(/.f64 (neg.f64 (log.f64 y)) y)
(neg.f64 (log.f64 y))
(log.f64 y)
y
#s(literal -1 binary64)
z
(log.f64 t)
t
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
#s(approx (- (- (log t) y) z) (neg.f64 y))
(neg.f64 y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z))
(*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x))
(*.f64 (/.f64 (log.f64 y) z) x)
(/.f64 (log.f64 y) z)
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))
#s(literal 3 binary64)
(pow.f64 (log.f64 t) #s(literal 3 binary64))
(fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))
(-.f64 (*.f64 y y) (*.f64 z y))
(*.f64 y y)
(*.f64 z y)
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))
#s(literal 2 binary64)
(-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))
(pow.f64 (log.f64 t) #s(literal 2 binary64))
(*.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))
(pow.f64 z #s(literal 3 binary64))
(pow.f64 y #s(literal 3 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 y)))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 -1))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (/ (* x (log y)) y) 1)))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 (* z (+ 1 (/ y z)))) (* x (log y)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (+ 1 (/ y z)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) (+ 1 (/ y z)))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (+ (* x (- (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (+ (* x (- (+ (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* x (- (/ (pow (log y) 3) (pow (log t) 2)) (+ (* -1 (/ (* (log y) (- (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (pow (log t) 2)))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (- (* -1 (* x (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))) (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (- (* x (- (* x (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))) (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (pow (log t) 3)))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* (pow x 3) (pow (log y) 3))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* -1 (* x (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* x (+ (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) (* x (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (pow (log t) 2)))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (+ (* -1 (* x (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (+ (* x (- (* x (pow (log y) 2)) (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (log y) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (pow (log t) 2)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (+ (* -1 (* x (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log t) (log y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* x (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* x (+ (* -1 (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* x (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (* x (- (/ (log y) y) (/ 1 x)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* x (+ (* -1 (/ (+ 1 (/ y z)) x)) (/ (log y) z)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (log y))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* -1 (/ (log t) x))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z))))) (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (pow x 2) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (+ (* -1 (/ (log t) x)) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 2) (log y)))) (/ (pow (log t) 2) (* (pow x 2) (log y)))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (pow x 2) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (/ (pow (log t) 3) (* (pow x 3) (pow (log y) 2)))))) (+ (* -1 (/ (log t) x)) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 2) (log y)))) (+ (* -1 (/ (* (log t) (- (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y))) (/ (pow (log t) 2) (log y))))) (* (pow x 3) (log y)))) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (* (pow x 3) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (/ (* (pow (log t) 2) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 3) (pow (log y) 2))) (/ (pow (log t) 2) (* (pow x 2) (log y))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (+ (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (- (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) (pow x 2))) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (- (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) (pow x 2))) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (pow x 3)) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 3) (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* (pow x 3) (pow (log y) 3))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* (pow x 3) (+ (/ (pow (log t) 3) (pow x 3)) (pow (log y) 3)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x)) (+ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (pow x 2)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (pow (log y) 2))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (log y)) x)) (pow (log y) 2)))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (- (+ (/ (pow (log t) 2) (pow x 2)) (pow (log y) 2)) (/ (* (log t) (log y)) x)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* -1 (* x (* (log t) (log y))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* x (- (/ (pow (log t) 2) x) (* (log t) (log y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) x)) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) x)) (+ (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 2)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (+ (/ 1 x) (/ y (* x z))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t))) x)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y)))) x))) (* -1 (log t))) x)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (+ (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (- (/ (pow (log t) 3) (pow (log y) 2)) (+ (/ (* (log t) (- (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y))))) (log y)) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))) (/ (* (pow (log t) 2) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (pow (log y) 2))))) x))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y)))) x))) (* -1 (log t))) x)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))) x)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))) x)) (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))) x)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (/ (pow (log t) 3) (pow x 3))) (* -1 (pow (log y) 3)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) x)) (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (- (* -1 (/ (pow (log t) 2) x)) (* -1 (* (log t) (log y)))) x)) (pow (log y) 2)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (pow (log t) 2) x)) (* -1 (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) x)) (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) x)) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (/ (+ (* -1 y) (* x (log y))) y)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (* -1 (/ (log y) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (log y))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 y)) z)))
#s(approx (neg y) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 y) (* z (- (/ (* x (log y)) z) 1)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (+ (* -1 (/ y z)) (/ (* x (log y)) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* y (- (/ 1 z) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* y (- (+ (* y (- (+ (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 5) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (/ (* x (* (log t) (log y))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (- (/ 1 z) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))) z)) (+ (/ (* (pow x 2) (pow (log y) 2)) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))) (/ 1 z)) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (pow z 2)))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* -1 (* y z)) (pow z 2))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* y (- y z)) (pow z 2))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* -1 (* y z))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* y (- y z))))
#s(approx (* y y) #s(hole binary64 (pow y 2)))
#s(approx (* z y) #s(hole binary64 (* y z)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* x (* (log t) (log y))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (pow z 3)))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (+ (pow y 3) (pow z 3))))
#s(approx (pow y 3) #s(hole binary64 (pow y 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* y (+ (* -1 (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (* -1 (/ (* x (log (/ 1 y))) y)) 1)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (/ (log (/ 1 y)) y)))
#s(approx (neg (log y)) #s(hole binary64 (log (/ 1 y))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* y (- (/ (* z (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)) y) 1))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (/ y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ 1 y) (/ 1 z))))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (* y (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 2))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (+ (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* z (- (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))) (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 3))) (+ (* -1 (/ (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 2))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (+ (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (/ (* (pow z 2) (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 3)) (+ (/ (pow z 3) (pow y 3)) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (/ (pow (log t) 3) y))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (/ (pow (log t) 3) y)))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 3)) (/ (pow (log t) 3) y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 3)) (pow (log t) 2)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) y)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) y)) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2)) (pow (log t) 3)))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3)))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (pow y 2)))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ z y))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (- (+ 1 (/ (pow z 2) (pow y 2))) (/ z y)))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (pow y 2)))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ z y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 3)) (pow (log t) 2))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (log (/ 1 y)) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* -1 (* x (* (log t) (log (/ 1 y))))))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (* (log t) (log (/ 1 y)))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (pow y 3)))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* (pow y 3) (+ 1 (/ (pow z 3) (pow y 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) y)) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) y)) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 2)) (pow (log t) 2)))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y) 1)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 y)))) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (log t) z) y)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* z (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)) y)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1) y)) (/ 1 z))))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z) y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2))) y)) (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))) z) y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (/ (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2)))) (+ (* (pow z 2) (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 3)))) y)) (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2))) y)) (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))) z) y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* -1 (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) y)) (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (- (* -1 (/ (pow z 2) y)) (* -1 z)) y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* -1 (* (pow y 3) (+ (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (* -1 (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (pow y 3))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (pow z 3) (pow y 3))) 1)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) y)) (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2))) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (+ (* -1 (/ (* (pow z 2) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) y)) (* z (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) y)) (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2))) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (* x (log y)) y) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (+ (* -1 z) (* x (log y))) y) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* z (- (/ 1 y) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* z (- (+ (* z (- (+ (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 5) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (/ (* x (* (log t) (log y))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (- (/ 1 y) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))) y)) (+ (/ (* (pow x 2) (pow (log y) 2)) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))) (/ 1 y)) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* z (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* -1 (* y z)) (pow y 2))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* z (- z y)) (pow y 2))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (+ (* -1 (* y z)) (pow y 2))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (pow z 3) #s(hole binary64 (pow z 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* z (+ (* -1 (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) z) (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 -1))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (* z (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 2))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))) (+ (* -1 (/ (* y (- (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (* -1 (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 3))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 2))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (/ (* (pow y 2) (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 3)) (+ (/ (pow y 3) (pow z 3)) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (/ (pow (log t) 3) z))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2))) (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (/ (pow (log t) 3) z)))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2))) (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 3)) (/ (pow (log t) 3) z))))) (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3)) (pow (log t) 2)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2)) (pow (log t) 3)))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (- (+ 1 (/ (pow y 2) (pow z 2))) (/ y z)))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* (pow z 3) (+ 1 (/ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 2)) (pow (log t) 2)))) (* x (* (log t) (log y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (- (+ 1 (* -1 (/ (* x (log y)) z))) (* -1 (/ y z)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (* -1 (/ (- (* -1 (* x (log y))) (* -1 y)) z)) 1)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y) z)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2))) z)) (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) y) z)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2)))) (+ (* (pow y 2) (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 3)))) z)) (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2))) z)) (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) y) z)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (+ 1 (* -1 (/ (- (* -1 (/ (pow y 2) z)) (* -1 y)) z))))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (pow y 2) z)) (* -1 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* -1 (* (pow z 3) (+ (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (* -1 (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3))))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (pow y 3) (pow z 3))) 1)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (+ (* -1 (/ (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (pow (log t) 3) #s(hole binary64 (pow (log t) 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (log t) 2)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (* -1 (log (/ 1 t))) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3)))))
#s(approx (pow (log t) 3) #s(hole binary64 (* -1 (pow (log (/ 1 t)) 3))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t))))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log (/ 1 t)) 2) (* -1 (* x (* (log y) (log (/ 1 t))))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (log (/ 1 t)) 2)))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (* (log y) (log (/ 1 t)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3))))
#s(approx (pow (log t) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
Calls

12 calls:

TimeVariablePointExpression
46.0ms
x
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (+ (* (neg x) (/ (neg (log y)) y)) -1) (neg x) x (/ (neg (log y)) y) (neg (log y)) (log y) y -1 z (log t) t (- (+ (* (log y) x) (log t)) (+ z y)) (* (log y) x) (+ (* (log y) x) (- (- (log t) y) z)) (- (- (log t) y) z) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (* (/ (log y) z) x) (/ (log y) z) (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow (* (log y) x) 3) 3 (pow (log t) 3) (+ (* z z) (- (* y y) (* z y))) (- (* y y) (* z y)) (* y y) (* z y) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow (* (log y) x) 2) 2 (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow (log t) 2) (* (* (log y) x) (log t)) (+ (pow z 3) (pow y 3)) (pow z 3) (pow y 3) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))))
34.0ms
y
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (+ (* (neg x) (/ (neg (log y)) y)) -1) (neg x) x (/ (neg (log y)) y) (neg (log y)) (log y) y -1 z (log t) t (- (+ (* (log y) x) (log t)) (+ z y)) (* (log y) x) (+ (* (log y) x) (- (- (log t) y) z)) (- (- (log t) y) z) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (* (/ (log y) z) x) (/ (log y) z) (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow (* (log y) x) 3) 3 (pow (log t) 3) (+ (* z z) (- (* y y) (* z y))) (- (* y y) (* z y)) (* y y) (* z y) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow (* (log y) x) 2) 2 (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow (log t) 2) (* (* (log y) x) (log t)) (+ (pow z 3) (pow y 3)) (pow z 3) (pow y 3) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))))
30.0ms
y
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (+ (* (neg x) (/ (neg (log y)) y)) -1) (neg x) x (/ (neg (log y)) y) (neg (log y)) (log y) y -1 z (log t) t (- (+ (* (log y) x) (log t)) (+ z y)) (* (log y) x) (+ (* (log y) x) (- (- (log t) y) z)) (- (- (log t) y) z) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (* (/ (log y) z) x) (/ (log y) z) (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow (* (log y) x) 3) 3 (pow (log t) 3) (+ (* z z) (- (* y y) (* z y))) (- (* y y) (* z y)) (* y y) (* z y) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow (* (log y) x) 2) 2 (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow (log t) 2) (* (* (log y) x) (log t)) (+ (pow z 3) (pow y 3)) (pow z 3) (pow y 3) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))))
28.0ms
x
@0
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (+ (* (neg x) (/ (neg (log y)) y)) -1) (neg x) x (/ (neg (log y)) y) (neg (log y)) (log y) y -1 z (log t) t (- (+ (* (log y) x) (log t)) (+ z y)) (* (log y) x) (+ (* (log y) x) (- (- (log t) y) z)) (- (- (log t) y) z) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (* (/ (log y) z) x) (/ (log y) z) (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow (* (log y) x) 3) 3 (pow (log t) 3) (+ (* z z) (- (* y y) (* z y))) (- (* y y) (* z y)) (* y y) (* z y) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow (* (log y) x) 2) 2 (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow (log t) 2) (* (* (log y) x) (log t)) (+ (pow z 3) (pow y 3)) (pow z 3) (pow y 3) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))))
23.0ms
x
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (- (* x (log y)) y) (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (+ (* (neg x) (/ (neg (log y)) y)) -1) (neg x) x (/ (neg (log y)) y) (neg (log y)) (log y) y -1 z (log t) t (- (+ (* (log y) x) (log t)) (+ z y)) (* (log y) x) (+ (* (log y) x) (- (- (log t) y) z)) (- (- (log t) y) z) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (- (- (* x (log y)) y) z) (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (- (+ (* x (/ (log y) z)) -1) (/ y z)) (* (/ (log y) z) x) (/ (log y) z) (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow (* (log y) x) 3) 3 (pow (log t) 3) (+ (* z z) (- (* y y) (* z y))) (- (* y y) (* z y)) (* y y) (* z y) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow (* (log y) x) 2) 2 (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow (log t) 2) (* (* (log y) x) (log t)) (+ (pow z 3) (pow y 3)) (pow z 3) (pow y 3) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))))

rewrite260.0ms (6.4%)

Memory
-31.0MiB live, 351.4MiB allocated; 84ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0166127463
0173825666
0820925218
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
427 → 523
Calls
Call 1
Inputs
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
(-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z)
#s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)
(fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64))
(neg.f64 x)
x
(/.f64 (neg.f64 (log.f64 y)) y)
(neg.f64 (log.f64 y))
(log.f64 y)
y
#s(literal -1 binary64)
z
(log.f64 t)
t
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
#s(approx (- (- (log t) y) z) (neg.f64 y))
(neg.f64 y)
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z))
(*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x))
(*.f64 (/.f64 (log.f64 y) z) x)
(/.f64 (log.f64 y) z)
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))
#s(literal 3 binary64)
(pow.f64 (log.f64 t) #s(literal 3 binary64))
(fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))
(-.f64 (*.f64 y y) (*.f64 z y))
(*.f64 y y)
(*.f64 z y)
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))
#s(literal 2 binary64)
(-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))
(pow.f64 (log.f64 t) #s(literal 2 binary64))
(*.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))
(pow.f64 z #s(literal 3 binary64))
(pow.f64 y #s(literal 3 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (+ y z))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) (+ y z))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 y)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 y)))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 -1))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (/ (* x (log y)) y) 1)))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) (+ y z))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 (* z (+ 1 (/ y z)))) (* x (log y)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (+ 1 (/ y z)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) (+ 1 (/ y z)))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (+ (* x (- (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (log t) (* x (- (+ (* x (- (+ (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* x (- (/ (pow (log y) 3) (pow (log t) 2)) (+ (* -1 (/ (* (log y) (- (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (pow (log t) 2)))))) (+ (* -1 (/ (* (log y) (- (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (log t))) (/ (* (pow (log y) 2) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 4) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (/ (* (log y) (+ (pow y 3) (pow z 3))) (* (log t) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (* (log y) (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))) (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (- (* -1 (* x (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))) (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* x (- (* x (- (* x (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))) (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (pow (log t) 3)))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* (pow x 3) (pow (log y) 3))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* -1 (* x (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* x (+ (* -1 (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) (* x (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (pow (log t) 2)))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (+ (* -1 (* x (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (+ (* x (- (* x (pow (log y) 2)) (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (log y) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (pow (log t) 2)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (+ (* -1 (* x (* (log t) (log y)))) (pow (log t) 2))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log t) (log y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* x (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* x (+ (* -1 (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* x (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (log y))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (log y))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (* x (- (/ (log y) y) (/ 1 x)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (log y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (log y))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* x (+ (* -1 (/ (+ 1 (/ y z)) x)) (/ (log y) z)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (log y))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z)))))) (* -1 (/ (log t) x))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z))))) (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (pow x 2) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))))) (+ (* -1 (/ (log t) x)) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 2) (log y)))) (/ (pow (log t) 2) (* (pow x 2) (log y)))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* x (- (+ (log y) (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (* x (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (pow x 2) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (/ (pow (log t) 3) (* (pow x 3) (pow (log y) 2)))))) (+ (* -1 (/ (log t) x)) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 2) (log y)))) (+ (* -1 (/ (* (log t) (- (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) (+ (* -1 (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y))) (/ (pow (log t) 2) (log y))))) (* (pow x 3) (log y)))) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (* (pow x 3) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (/ (* (pow (log t) 2) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (* (pow x 3) (pow (log y) 2))) (/ (pow (log t) 2) (* (pow x 2) (log y))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (+ (* -1 (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (- (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) (pow x 2))) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow x 3) (- (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) (pow x 2))) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (pow x 3)) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 3) (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 3) (+ (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* (pow x 3) (pow (log y) 3))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* (pow x 3) (+ (/ (pow (log t) 3) (pow x 3)) (pow (log y) 3)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (* (pow (log y) 2) (+ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x)) (+ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (pow x 2)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (pow (log y) 2))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (log y)) x)) (pow (log y) 2)))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (- (+ (/ (pow (log t) 2) (pow x 2)) (pow (log y) 2)) (/ (* (log t) (log y)) x)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* -1 (* x (* (log t) (log y))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* x (- (/ (pow (log t) 2) x) (* (log t) (log y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) x)) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z)))) x)) (+ (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) (/ (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 2)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (+ (/ y x) (/ z x)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y z)) x)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (+ 1 (/ y z))) x))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (+ (/ 1 x) (/ y (* x z))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t))) x)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y)))) x))) (* -1 (log t))) x)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (+ (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (+ (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (* -1 (/ (- (/ (pow (log t) 3) (pow (log y) 2)) (+ (/ (* (log t) (- (* -1 (/ (* (log t) (+ (pow y 3) (pow z 3))) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y))))) (log y)) (+ (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))) (/ (* (pow (log t) 2) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (pow (log y) 2))))) x))) (+ (* -1 (/ (pow (log t) 2) (log y))) (/ (* (log t) (- (* -1 (/ (+ (pow y 3) (pow z 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (log t)))) (log y)))) x))) (* -1 (log t))) x)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (/ (* (pow (log y) 2) (+ (pow y 3) (pow z 3))) x))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (/ (* (log t) (* (log y) (+ (pow y 3) (pow z 3)))) x) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))) x)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (- (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (pow (log t) 2) (+ (pow y 3) (pow z 3)))) x)) (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))) x)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (* (pow (log y) 3) (- (+ (pow y 2) (pow z 2)) (* y z)))) (* -1 (/ (* (pow (log t) 3) (- (+ (pow y 2) (pow z 2)) (* y z))) (pow x 3))))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (* -1 (* (pow x 3) (+ (* -1 (/ (pow (log t) 3) (pow x 3))) (* -1 (pow (log y) 3)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow (log t) 2) (+ (pow y 3) (pow z 3))) x)) (* (log t) (* (log y) (+ (pow y 3) (pow z 3))))) x)) (* (pow (log y) 2) (+ (pow y 3) (pow z 3)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (- (* -1 (/ (pow (log t) 2) x)) (* -1 (* (log t) (log y)))) x)) (pow (log y) 2)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (pow (log t) 2) x)) (* -1 (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow x 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow (log t) 2) (- (+ (pow y 2) (pow z 2)) (* y z))) x)) (* (log t) (* (log y) (- (+ (pow y 2) (pow z 2)) (* y z))))) x)) (* (pow (log y) 2) (- (+ (pow y 2) (pow z 2)) (* y z)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 y) (* x (log y))) z)))
#s(approx (- (* x (log y)) y) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (/ (+ (* -1 y) (* x (log y))) y)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (* -1 (/ (log y) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (log y))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 y) (* x (log y)))) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 y)) z)))
#s(approx (neg y) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) 1))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (+ (* -1 y) (* z (- (/ (* x (log y)) z) 1)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (/ (* x (log y)) z) 1)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (+ (* -1 (/ y z)) (/ (* x (log y)) z)) 1)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* y (- (/ 1 z) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* y (- (+ (* y (- (+ (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 5) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (/ (* x (* (log t) (log y))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (- (/ 1 z) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))) z)) (+ (/ (* (pow x 2) (pow (log y) 2)) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))) (/ 1 z)) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) z))))) (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* y (+ (* -1 (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow z 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (pow z 2)))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* -1 (* y z)) (pow z 2))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* y (- y z)) (pow z 2))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* -1 (* y z))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* y (- y z))))
#s(approx (* y y) #s(hole binary64 (pow y 2)))
#s(approx (* z y) #s(hole binary64 (* y z)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (+ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* x (* (log t) (log y))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (pow z 3)))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (+ (pow y 3) (pow z 3))))
#s(approx (pow y 3) #s(hole binary64 (pow y 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* y (+ (* -1 (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) (+ 1 (/ z y))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (* -1 (/ (* x (log (/ 1 y))) y)) 1)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (/ (log (/ 1 y)) y)))
#s(approx (neg (log y)) #s(hole binary64 (log (/ 1 y))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* y (- (/ (* z (- (* -1 (/ (* x (log (/ 1 y))) z)) 1)) y) 1))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (/ y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ 1 y) (/ 1 z))))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (* y (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 2))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (+ (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (* (log t) (log (/ 1 y)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))))) (+ (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* y (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))) (+ (* -1 (/ (* z (- (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (* -1 (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))) (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 3))) (+ (* -1 (/ (* z (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 2))) (+ (/ (* (pow x 2) (pow (log (/ 1 y)) 2)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (+ (/ (* (pow z 2) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (+ (/ (* (pow z 2) (- (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))) (* -1 (/ (* z (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))) (pow y 3)) (+ (/ (pow z 3) (pow y 3)) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (/ (pow (log t) 3) y))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (/ (pow (log t) 3) y)))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow y 3) (- (+ (* -1 (* x (* (log t) (log (/ 1 y))))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2))) (+ (* -1 (/ (* (pow x 3) (pow (log (/ 1 y)) 3)) y)) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 3)) (/ (pow (log t) 3) y))))) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 3)) (pow (log t) 2)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) y)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (+ (* -1 (/ (* z (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) y)) (+ (/ (* (pow z 2) (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))) (pow y 2)) (pow (log t) 3)))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3))) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* -1 (* (pow x 3) (pow (log (/ 1 y)) 3)))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (pow y 2)))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ z y))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (- (+ 1 (/ (pow z 2) (pow y 2))) (/ z y)))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (pow y 2)))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ z y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 3)) (pow (log t) 2))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (log (/ 1 y)) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* -1 (* x (* (log t) (log (/ 1 y))))))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (* (log t) (log (/ 1 y)))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (pow y 3)))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* (pow y 3) (+ 1 (/ (pow z 3) (pow y 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) y)) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) y)) (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (+ (/ (* (pow z 2) (- (+ (* (pow x 2) (pow (log (/ 1 y)) 2)) (pow (log t) 2)) (* -1 (* x (* (log t) (log (/ 1 y))))))) (pow y 2)) (pow (log t) 2)))) (* -1 (* x (* (log t) (log (/ 1 y)))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) y)))))))
#s(approx (- (* x (log y)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(hole binary64 (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y) 1)))
#s(approx (/ (neg (log y)) y) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 y)))) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z) y)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (log t) z) y)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* z (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1)) y)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (- (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z) 1) y)) (/ 1 z))))))
#s(approx (* (/ (log y) z) x) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z) y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2))) y)) (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))) z) y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (/ (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2)))) (+ (* (pow z 2) (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 3)))) y)) (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) (+ (* z (- (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) z)) (pow z 2))) y)) (+ (/ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))) z) y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* -1 (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (- (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) y)) (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow z 2) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))) y)) (* z (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3)))) y)) (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3)) (pow (log t) 3))))
#s(approx (pow (* (log y) x) 3) #s(hole binary64 (* (pow x 3) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 3))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (- (* -1 (/ (pow z 2) y)) (* -1 z)) y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* -1 (* (pow y 3) (+ (* -1 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (* -1 (/ (* (pow z 3) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) (pow y 3))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (pow (* (log y) x) 2) #s(hole binary64 (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log t) 2) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* -1 (* (pow y 3) (- (* -1 (/ (pow z 3) (pow y 3))) 1)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (* z (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) y)) (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2))) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* -1 (/ (+ (* -1 (/ (* (pow z 2) (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y)))))))) y)) (* z (- (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2)) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))) y)) (+ (* (pow x 2) (pow (+ (log -1) (* -1 (log (/ -1 y)))) 2)) (pow (log t) 2))) (* x (* (log t) (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx z #s(hole binary64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) y)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (* x (log y)) y) z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (/ (- (+ (* -1 z) (* x (log y))) y) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* z (- (/ 1 y) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (- (+ (* z (- (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* z (- (+ (* z (- (+ (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 5) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (/ (* x (* (log t) (log y))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (- (/ 1 y) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))) y)) (+ (/ (* (pow x 2) (pow (log y) 2)) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))) (/ 1 y)) (* -1 (/ (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) y))))) (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* z (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* z (+ (* -1 (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) (* z (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))) (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* -1 (* y z)) (pow y 2))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (+ (* z (- z y)) (pow y 2))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (+ (* -1 (* y z)) (pow y 2))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (pow z 3) #s(hole binary64 (pow z 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* -1 (* y (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (+ (* z (+ (* -1 (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 z)))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) z) (+ 1 (/ y z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 -1))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (* z (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 2))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* z (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (/ (* x (* (log t) (log y))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow x 3) (pow (log y) 3)) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (/ (pow (log t) 3) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))))) (+ (* -1 (/ (* y (- (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (* -1 (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))) (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 3))) (+ (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* z (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) (+ (* -1 (/ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 2))) (+ (/ (* (pow x 2) (pow (log y) 2)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (/ (* (pow y 2) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (* (pow z 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (/ (* (pow y 2) (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* -1 (/ (* y (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))) (pow z 3)) (+ (/ (pow y 3) (pow z 3)) (/ (pow (log t) 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (* x (* (log t) (log y))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (/ (pow (log t) 3) z))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2))) (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (/ (pow (log t) 3) z)))) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* (pow z 3) (- (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2))) (+ (* x (* (log t) (log y))) (+ (/ (* (pow x 3) (pow (log y) 3)) z) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 3)) (/ (pow (log t) 3) z))))) (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3)) (pow (log t) 2)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (+ (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (pow z 2)) (pow (log t) 3)))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (- (+ 1 (/ (pow y 2) (pow z 2))) (/ y z)))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* (pow z 3) (+ 1 (/ (pow y 3) (pow z 3))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (+ (/ (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 2)) (pow (log t) 2)))) (* x (* (log t) (log y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (* x (log y)) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (* x (log y)) y) z)))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) #s(hole binary64 (* -1 (* z (- (+ 1 (* -1 (/ (* x (log y)) z))) (* -1 (/ y z)))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(hole binary64 (- (* -1 (/ (- (* -1 (* x (log y))) (* -1 y)) z)) 1)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y) z)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2))) z)) (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) y) z)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2)))) (+ (* (pow y 2) (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 3)))) z)) (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (+ (* y (- (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) y)) (pow y 2))) z)) (+ (/ (* (pow x 3) (pow (log y) 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (/ (pow (log t) 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))) y) z)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* -1 (/ (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (- (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (+ (* -1 (/ (+ (* -1 (/ (* (pow y 2) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))) z)) (* y (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)))) z)) (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) #s(hole binary64 (* (pow z 2) (+ 1 (* -1 (/ (- (* -1 (/ (pow y 2) z)) (* -1 y)) z))))))
#s(approx (- (* y y) (* z y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (pow y 2) z)) (* -1 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* -1 (* (pow z 3) (+ (* -1 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (* -1 (/ (* (pow y 3) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) (pow z 3))))))))
#s(approx (+ (pow z 3) (pow y 3)) #s(hole binary64 (* -1 (* (pow z 3) (- (* -1 (/ (pow y 3) (pow z 3))) 1)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (pow z 2) (- (+ (* -1 (/ (+ (* -1 (/ (* (pow y 2) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))) z)) (* y (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) z)) (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2))) (* x (* (log t) (log y)))))))
#s(approx (log t) #s(hole binary64 (log t)))
#s(approx t #s(hole binary64 t))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* (pow x 3) (pow (log y) 3)) (pow (log t) 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (pow (log t) 3) #s(hole binary64 (pow (log t) 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (log t) 2)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log t) 2)) (* x (* (log t) (log y)))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (* -1 (log (/ 1 t))) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* -1 (pow (log (/ 1 t)) 3)) (* (pow x 3) (pow (log y) 3)))))
#s(approx (pow (log t) 3) #s(hole binary64 (* -1 (pow (log (/ 1 t)) 3))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t))))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (log (/ 1 t)) 2) (* -1 (* x (* (log y) (log (/ 1 t))))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (log (/ 1 t)) 2)))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (* (log y) (log (/ 1 t)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (log (/ 1 t)) 2)) (* -1 (* x (* (log y) (log (/ 1 t)))))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) (+ y z))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) (+ y z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) #s(hole binary64 (/ (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))) (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))) (- (+ (pow y 2) (pow z 2)) (* y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) #s(hole binary64 (- (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z))) (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)) (- (+ (pow y 2) (pow z 2)) (* y z)))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) #s(hole binary64 (+ (* (pow x 3) (pow (log y) 3)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3))))
#s(approx (pow (log t) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 t)))) 3)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) #s(hole binary64 (* (+ (pow y 3) (pow z 3)) (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) #s(hole binary64 (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) #s(hole binary64 (- (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t)))))))))
#s(approx (pow (log t) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)))
#s(approx (* (* (log y) x) (log t)) #s(hole binary64 (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) #s(hole binary64 (* (- (+ (* (pow x 2) (pow (log y) 2)) (pow (+ (log -1) (* -1 (log (/ -1 t)))) 2)) (* x (* (log y) (+ (log -1) (* -1 (log (/ -1 t))))))) (- (+ (pow y 2) (pow z 2)) (* y z)))))
Outputs
(/.f64 (-.f64 (*.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (log.f64 t)))))
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z) (log.f64 t))
(/.f64 (-.f64 (*.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y))) (*.f64 z z)) (+.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z))
(/.f64 (-.f64 (pow.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) (fma.f64 z z (*.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z))))
(-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)) z)
#s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y))
(*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y)
(/.f64 (-.f64 (*.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)))) #s(literal 1 binary64)) (-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal -1 binary64)))
(/.f64 (+.f64 (pow.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 3 binary64)) #s(literal -1 binary64)) (fma.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal -1 binary64)))))
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal -1 binary64))
(neg.f64 x)
x
(/.f64 (neg.f64 (neg.f64 (log.f64 y))) (neg.f64 y))
(/.f64 (neg.f64 (log.f64 y)) y)
(neg.f64 (/.f64 (log.f64 y) y))
(*.f64 #s(literal -1 binary64) (log.f64 y))
(neg.f64 (log.f64 y))
(-.f64 #s(literal 0 binary64) (log.f64 y))
(log.f64 (pow.f64 y #s(literal -1 binary64)))
(log.f64 y)
y
#s(literal -1 binary64)
z
(log.f64 t)
t
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (log t) y) z) (neg.f64 y)) #s(approx (- (- (log t) y) z) (neg.f64 y)))) (-.f64 (*.f64 (log.f64 y) x) #s(approx (- (- (log t) y) z) (neg.f64 y))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 #s(approx (- (- (log t) y) z) (neg.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 #s(approx (- (- (log t) y) z) (neg.f64 y)) #s(approx (- (- (log t) y) z) (neg.f64 y))) (*.f64 (*.f64 (log.f64 y) x) #s(approx (- (- (log t) y) z) (neg.f64 y))))))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(+.f64 (*.f64 (log.f64 y) x) #s(approx (- (- (log t) y) z) (neg.f64 y)))
#s(approx (- (- (log t) y) z) (neg.f64 y))
(neg.f64 y)
(/.f64 (-.f64 (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z))) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t)))
(/.f64 (+.f64 (pow.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t)))))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z))
(*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x))
(*.f64 (/.f64 (log.f64 y) z) x)
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 z))
(/.f64 (log.f64 y) z)
(/.f64 (neg.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))) (neg.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))))
(-.f64 (/.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))) (/.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))) (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))) (fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) #s(literal 3 binary64))) (fma.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (fma.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))
(-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))
(+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z z) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 y y (*.f64 (neg.f64 z) y))))
(+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 y y (*.f64 (neg.f64 z) y))))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 (log.f64 y) x (log.f64 t)))
(/.f64 (-.f64 (*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))
(/.f64 (+.f64 (pow.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) #s(literal 3 binary64)) (pow.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (-.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
(fma.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3/2 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(fma.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 x #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(fma.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 y) x) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(fma.f64 (*.f64 (log.f64 y) x) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3/2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 x #s(literal 3 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 y) x))
(*.f64 (*.f64 (log.f64 y) x) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))
#s(literal 3 binary64)
(*.f64 (pow.f64 (log.f64 t) #s(literal 3/2 binary64)) (pow.f64 (log.f64 t) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 t))
(*.f64 (log.f64 t) (pow.f64 (log.f64 t) #s(literal 2 binary64)))
(pow.f64 (log.f64 t) #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 t)) #s(literal 3 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z z)) (*.f64 (fma.f64 y y (*.f64 (neg.f64 z) y)) (fma.f64 y y (*.f64 (neg.f64 z) y)))) (-.f64 (*.f64 z z) (fma.f64 y y (*.f64 (neg.f64 z) y))))
(/.f64 (+.f64 (pow.f64 (*.f64 z z) #s(literal 3 binary64)) (pow.f64 (fma.f64 y y (*.f64 (neg.f64 z) y)) #s(literal 3 binary64))) (fma.f64 (*.f64 z z) (*.f64 z z) (-.f64 (*.f64 (fma.f64 y y (*.f64 (neg.f64 z) y)) (fma.f64 y y (*.f64 (neg.f64 z) y))) (*.f64 (*.f64 z z) (fma.f64 y y (*.f64 (neg.f64 z) y))))))
(fma.f64 (pow.f64 z #s(literal 1 binary64)) (pow.f64 z #s(literal 1 binary64)) (fma.f64 y y (*.f64 (neg.f64 z) y)))
(fma.f64 (neg.f64 z) (neg.f64 z) (fma.f64 y y (*.f64 (neg.f64 z) y)))
(fma.f64 (fabs.f64 z) (fabs.f64 z) (fma.f64 y y (*.f64 (neg.f64 z) y)))
(fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y)))
(+.f64 (*.f64 z z) (fma.f64 y y (*.f64 (neg.f64 z) y)))
(/.f64 (-.f64 (*.f64 (*.f64 y y) (*.f64 y y)) (*.f64 (*.f64 z y) (*.f64 z y))) (fma.f64 y y (*.f64 z y)))
(/.f64 (-.f64 (pow.f64 (*.f64 y y) #s(literal 3 binary64)) (pow.f64 (*.f64 z y) #s(literal 3 binary64))) (fma.f64 (*.f64 y y) (*.f64 y y) (fma.f64 (*.f64 z y) (*.f64 z y) (*.f64 (*.f64 y y) (*.f64 z y)))))
(fma.f64 (pow.f64 y #s(literal 1 binary64)) (pow.f64 y #s(literal 1 binary64)) (*.f64 (neg.f64 z) y))
(fma.f64 (fabs.f64 y) (fabs.f64 y) (*.f64 (neg.f64 z) y))
(fma.f64 (neg.f64 y) (neg.f64 y) (*.f64 (neg.f64 z) y))
(fma.f64 y y (*.f64 (neg.f64 z) y))
(-.f64 (*.f64 y y) (*.f64 z y))
(+.f64 (*.f64 y y) (*.f64 (neg.f64 z) y))
(*.f64 (pow.f64 y #s(literal 1 binary64)) (pow.f64 y #s(literal 1 binary64)))
(*.f64 (fabs.f64 y) (fabs.f64 y))
(*.f64 (neg.f64 y) (neg.f64 y))
(*.f64 y y)
(pow.f64 y #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 y) #s(literal 2 binary64)))
(*.f64 z y)
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (pow.f64 z #s(literal 3 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (pow.f64 y #s(literal 3 binary64))))
(+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (pow.f64 z #s(literal 3 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (pow.f64 y #s(literal 3 binary64))))
(/.f64 (-.f64 (*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))))
(/.f64 (+.f64 (pow.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) #s(literal 3 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))) #s(literal 3 binary64))) (fma.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))))))
(fma.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 1 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(fma.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (*.f64 x x) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(fma.f64 (*.f64 (log.f64 y) x) (*.f64 (log.f64 y) x) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(*.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (*.f64 x x))
(*.f64 (*.f64 (log.f64 y) x) (*.f64 (log.f64 y) x))
(pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))
#s(literal 2 binary64)
(/.f64 (-.f64 (pow.f64 (log.f64 t) #s(literal 4 binary64)) (*.f64 (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 (log.f64 t) (log.f64 t) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))
(/.f64 (-.f64 (pow.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 t) #s(literal 4 binary64)) (fma.f64 (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t))))))
(fma.f64 (pow.f64 (log.f64 t) #s(literal 1 binary64)) (pow.f64 (log.f64 t) #s(literal 1 binary64)) (*.f64 (neg.f64 (*.f64 (log.f64 y) x)) (log.f64 t)))
(fma.f64 (log.f64 t) (log.f64 t) (*.f64 (neg.f64 (*.f64 (log.f64 y) x)) (log.f64 t)))
(-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))
(+.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (neg.f64 (*.f64 (log.f64 y) x)) (log.f64 t)))
(*.f64 (pow.f64 (log.f64 t) #s(literal 1 binary64)) (pow.f64 (log.f64 t) #s(literal 1 binary64)))
(*.f64 (log.f64 t) (log.f64 t))
(pow.f64 (log.f64 t) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 t)) #s(literal 2 binary64)))
(*.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(log.f64 (pow.f64 t (*.f64 (log.f64 y) x)))
(*.f64 (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))) (+.f64 z y))
(/.f64 (-.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))) (-.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))
(/.f64 (+.f64 (pow.f64 (pow.f64 z #s(literal 3 binary64)) #s(literal 3 binary64)) (pow.f64 (pow.f64 y #s(literal 3 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)) (-.f64 (*.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))))
(fma.f64 (pow.f64 z #s(literal 3/2 binary64)) (pow.f64 z #s(literal 3/2 binary64)) (pow.f64 y #s(literal 3 binary64)))
(fma.f64 (*.f64 z z) z (pow.f64 y #s(literal 3 binary64)))
(fma.f64 z (*.f64 z z) (pow.f64 y #s(literal 3 binary64)))
(+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64)))
(*.f64 (pow.f64 z #s(literal 3/2 binary64)) (pow.f64 z #s(literal 3/2 binary64)))
(*.f64 (*.f64 z z) z)
(*.f64 z (*.f64 z z))
(pow.f64 z #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 z) #s(literal 3 binary64)))
(*.f64 (pow.f64 y #s(literal 3/2 binary64)) (pow.f64 y #s(literal 3/2 binary64)))
(*.f64 (*.f64 y y) y)
(*.f64 y (*.f64 y y))
(pow.f64 y #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 y) #s(literal 3 binary64)))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (fma.f64 y y (*.f64 (neg.f64 z) y))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (*.f64 z z) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 y y (*.f64 (neg.f64 z) y))))
(+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (*.f64 z z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 y y (*.f64 (neg.f64 z) y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (log.f64 t) (+.f64 y z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) (+.f64 y z)))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 x (log.f64 y)) (+.f64 y z)))
#s(approx (- (* x (log y)) y) (*.f64 #s(literal -1 binary64) y))
#s(approx (- (* x (log y)) y) (-.f64 (*.f64 x (log.f64 y)) y))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 #s(literal -1 binary64) y))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) #s(literal -1 binary64))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (-.f64 (/.f64 (*.f64 x (log.f64 y)) y) #s(literal 1 binary64)))
#s(approx (neg x) (*.f64 #s(literal -1 binary64) x))
#s(approx x x)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (log.f64 t) (+.f64 y z)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (* (log y) x) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (log.f64 t) (+.f64 y z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (fma.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 y z))) (*.f64 x (log.f64 y))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 #s(literal -1 binary64) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
#s(approx (* (/ (log y) z) x) (/.f64 (*.f64 x (log.f64 y)) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (+.f64 (log.f64 t) (*.f64 x (fma.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (+.f64 (log.f64 t) (*.f64 x (-.f64 (fma.f64 x (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) (fma.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (log.f64 t)) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 4 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))) (*.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (+.f64 (log.f64 t) (*.f64 x (-.f64 (fma.f64 x (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 x (-.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) (fma.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (log.f64 t)) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 4 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (log.f64 t)) (/.f64 (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (fma.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) (fma.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (log.f64 t)) (*.f64 (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 4 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))) (*.f64 (/.f64 (log.f64 y) (log.f64 t)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 y) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 x (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 x (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 x (fma.f64 x (fma.f64 x (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 (neg.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 (pow.f64 x #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))
#s(approx (pow (* (log y) x) 3) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (fma.f64 x (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 x (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (pow.f64 (log.f64 t) #s(literal 2 binary64))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (fma.f64 x (-.f64 (*.f64 x (pow.f64 (log.f64 y) #s(literal 2 binary64))) (*.f64 (log.f64 t) (log.f64 y))) (pow.f64 (log.f64 t) #s(literal 2 binary64))))
#s(approx (pow (* (log y) x) 2) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (pow.f64 (log.f64 t) #s(literal 2 binary64))))
#s(approx (* (* (log y) x) (log t)) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 x (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 x (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 x (log.f64 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 x (-.f64 (+.f64 (log.f64 y) (/.f64 (log.f64 t) x)) (/.f64 (+.f64 y z) x))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 x (log.f64 y)))
#s(approx (- (- (* x (log y)) y) z) (*.f64 x (-.f64 (log.f64 y) (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)))))
#s(approx (- (* x (log y)) y) (*.f64 x (log.f64 y)))
#s(approx (- (* x (log y)) y) (*.f64 x (-.f64 (log.f64 y) (*.f64 #s(literal 1 binary64) (/.f64 y x)))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 x (log.f64 y)))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 x (-.f64 (log.f64 y) (*.f64 #s(literal 1 binary64) (/.f64 y x)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (/.f64 (*.f64 x (log.f64 y)) y))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (*.f64 x (-.f64 (/.f64 (log.f64 y) y) (pow.f64 x #s(literal -1 binary64)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 x (log.f64 y)))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 x (-.f64 (+.f64 (log.f64 y) (/.f64 (log.f64 t) x)) (/.f64 (+.f64 y z) x))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 x (-.f64 (+.f64 (log.f64 y) (/.f64 (log.f64 t) x)) (/.f64 (+.f64 y z) x))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 x (log.f64 y)))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 x (-.f64 (log.f64 y) (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 y z))) x)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (*.f64 x (log.f64 y)) z))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 x (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) x) (/.f64 (log.f64 y) z))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 x (log.f64 y)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 x (-.f64 (-.f64 (log.f64 y) (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 x (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 t) x)))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 x (-.f64 (+.f64 (log.f64 y) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 x (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 (/.f64 (log.f64 t) (*.f64 x x)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 t) x) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (*.f64 x x)) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t))) (log.f64 y))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 x x) (log.f64 y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 x (-.f64 (+.f64 (log.f64 y) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 x (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (fma.f64 (/.f64 (log.f64 t) (*.f64 x x)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (*.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 t) x) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (*.f64 x x)) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t))) (log.f64 y))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (pow.f64 x #s(literal 3 binary64))) (/.f64 (-.f64 (*.f64 (/.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t)))) (log.f64 y)) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 y)))) (log.f64 y))) (fma.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 x #s(literal 3 binary64))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (fma.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 x #s(literal 3 binary64))) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t))) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 x x) (log.f64 y)))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (-.f64 (fma.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 x x))) (/.f64 (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) x))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (-.f64 (fma.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (pow.f64 x #s(literal 3 binary64)))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 x x)) (+.f64 (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (pow.f64 x #s(literal 3 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) x))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (pow.f64 x #s(literal 3 binary64))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (*.f64 (pow.f64 x #s(literal 3 binary64)) (+.f64 (pow.f64 (/.f64 (log.f64 t) x) #s(literal 3 binary64)) (pow.f64 (log.f64 y) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (*.f64 x x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x) (fma.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (*.f64 x x))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (log.f64 y)) x) (pow.f64 (log.f64 y) #s(literal 2 binary64)))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (*.f64 (*.f64 x x) (-.f64 (+.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 x x)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 t) (log.f64 y)) x))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (*.f64 x (-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) x) (*.f64 (log.f64 t) (log.f64 y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 x x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) x) (fma.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 x x))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(literal -1 binary64) (*.f64 x (+.f64 (neg.f64 (log.f64 y)) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (log.f64 t) (+.f64 y z)) x))))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (+.f64 y z) x)))))
#s(approx (- (* x (log y)) y) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 y x)))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 y x)))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) y) (pow.f64 x #s(literal -1 binary64))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 #s(literal -1 binary64) (*.f64 x (+.f64 (neg.f64 (log.f64 y)) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (log.f64 t) (+.f64 y z)) x))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 #s(literal -1 binary64) (*.f64 x (+.f64 (neg.f64 (log.f64 y)) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (log.f64 t) (+.f64 y z)) x))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (/.f64 (*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 y z))) x)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) z) (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 y (*.f64 x z)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t))) x))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 y)) (/.f64 (*.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t)))) (log.f64 y)))) x))) (neg.f64 (log.f64 t))) x))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (log.f64 y) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (log.f64 t) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 y)) (/.f64 (*.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t)))) (log.f64 y))))) (log.f64 y)) (fma.f64 (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (log.f64 y) #s(literal 2 binary64)))))) x))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (log.f64 y)) (/.f64 (*.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal 1 binary64) (log.f64 t)))) (log.f64 y)))) x))) (neg.f64 (log.f64 t))) x))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (/.f64 (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) x)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x) (*.f64 (neg.f64 (log.f64 t)) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))) x) (*.f64 (neg.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) x))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) (pow.f64 x #s(literal 3 binary64))))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 x #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (log.f64 t) x) #s(literal 3 binary64)) (*.f64 #s(literal -1 binary64) (pow.f64 (log.f64 y) #s(literal 3 binary64)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) x) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) x) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (log.f64 y)))) x) (pow.f64 (log.f64 y) #s(literal 2 binary64)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (*.f64 #s(literal -1 binary64) (*.f64 x (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) x) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 x x) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))) x) (*.f64 (log.f64 t) (*.f64 (log.f64 y) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) x) (*.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y)))) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 x (log.f64 y)) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y))) z))
#s(approx (- (* x (log y)) y) (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (/.f64 (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y))) y))
#s(approx (/ (neg (log y)) y) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) y)))
#s(approx (neg (log y)) (neg.f64 (log.f64 y)))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y)))) z))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) y (*.f64 x (log.f64 y)))) z))
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z))
#s(approx (- (- (log t) y) z) (-.f64 (-.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) y)) z))
#s(approx (neg y) (*.f64 #s(literal -1 binary64) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 z (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) #s(literal 1 binary64))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (fma.f64 #s(literal -1 binary64) y (*.f64 z (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) #s(literal 1 binary64)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) #s(literal 1 binary64)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 y z) (/.f64 (*.f64 x (log.f64 y)) z)) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (/.f64 (log.f64 y) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 y (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 y (-.f64 (pow.f64 z #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) z))))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 y (-.f64 (fma.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 5 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (/.f64 x (*.f64 z z)) (/.f64 (*.f64 (log.f64 t) (log.f64 y)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 z #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) z))) z) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))))) (pow.f64 z #s(literal -1 binary64))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) z))))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) z))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 y (fma.f64 #s(literal -1 binary64) (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 y (fma.f64 #s(literal -1 binary64) (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y (fma.f64 y (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 y (fma.f64 #s(literal -1 binary64) (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 z z))
#s(approx (+ (* z z) (- (* y y) (* z y))) (fma.f64 #s(literal -1 binary64) (*.f64 y z) (*.f64 z z)))
#s(approx (+ (* z z) (- (* y y) (* z y))) (fma.f64 y (-.f64 y z) (*.f64 z z)))
#s(approx (- (* y y) (* z y)) (*.f64 #s(literal -1 binary64) (*.f64 y z)))
#s(approx (- (* y y) (* z y)) (*.f64 y (-.f64 y z)))
#s(approx (* y y) (*.f64 y y))
#s(approx (* z y) (*.f64 y z))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (fma.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))
#s(approx (+ (pow z 3) (pow y 3)) (pow.f64 z #s(literal 3 binary64)))
#s(approx (+ (pow z 3) (pow y 3)) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
#s(approx (pow y 3) (pow.f64 y #s(literal 3 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 y (fma.f64 #s(literal -1 binary64) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(literal -1 binary64) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y) (/.f64 (log.f64 t) y)) (+.f64 #s(literal 1 binary64) (/.f64 z y)))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) y))
#s(approx (- (- (* x (log y)) y) z) (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y)) (+.f64 #s(literal 1 binary64) (/.f64 z y)))))
#s(approx (- (* x (log y)) y) (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y)) #s(literal 1 binary64))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y)) #s(literal 1 binary64))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y)) #s(literal 1 binary64)))
#s(approx (/ (neg (log y)) y) (neg.f64 (/.f64 (log.f64 y) y)))
#s(approx (neg (log y)) (neg.f64 (log.f64 y)))
#s(approx (log y) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 y))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 #s(literal -1 binary64) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y) (/.f64 (log.f64 t) y)) (+.f64 #s(literal 1 binary64) (/.f64 z y)))))
#s(approx (* (log y) x) (*.f64 #s(literal -1 binary64) (*.f64 x (neg.f64 (log.f64 y)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 #s(literal -1 binary64) y))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) y) (/.f64 (log.f64 t) y)) (+.f64 #s(literal 1 binary64) (/.f64 z y)))))
#s(approx (- (- (log t) y) z) (*.f64 #s(literal -1 binary64) y))
#s(approx (- (- (log t) y) z) (*.f64 y (-.f64 (/.f64 (log.f64 t) y) (+.f64 #s(literal 1 binary64) (/.f64 z y)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 y (-.f64 (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) z)) #s(literal 1 binary64))) y) #s(literal 1 binary64))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 #s(literal -1 binary64) (/.f64 y z)))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (/.f64 x y) (/.f64 (neg.f64 (log.f64 y)) z))) (+.f64 (pow.f64 y #s(literal -1 binary64)) (pow.f64 z #s(literal -1 binary64))))))
#s(approx (* (/ (log y) z) x) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (neg.f64 (log.f64 y))) z)))
#s(approx (/ (log y) z) (*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 y)) z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 z y) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 z (*.f64 y y)) (/.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 z y) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (*.f64 y y)) (+.f64 (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (fma.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 y (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 z (*.f64 y y)) (/.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 (/.f64 (*.f64 z z) (pow.f64 y #s(literal 3 binary64))) (/.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 z y) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (*.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (/.f64 (*.f64 (*.f64 z z) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (pow.f64 y #s(literal 3 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (*.f64 y y)) (+.f64 (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (fma.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (+.f64 (/.f64 (*.f64 (*.f64 z z) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))) (pow.f64 y #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 z y) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) y) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) y))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y y)) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) y) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) y)))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y y)) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) y) (+.f64 (/.f64 (*.f64 (*.f64 z z) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (pow.f64 y #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) y))))) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (pow.f64 y #s(literal 3 binary64))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (+.f64 (/.f64 (*.f64 (*.f64 z z) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 y y)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))
#s(approx (pow (* (log y) x) 3) (*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 3 binary64))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 y y))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 y y) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 z y)))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 y y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 z z) (*.f64 y y))) (/.f64 z y))))
#s(approx (- (* y y) (* z y)) (*.f64 y y))
#s(approx (- (* y y) (* z y)) (*.f64 (*.f64 y y) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 z y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (pow.f64 y #s(literal 3 binary64))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))
#s(approx (pow (* (log y) x) 2) (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (fma.f64 (log.f64 t) (log.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y)))))))
#s(approx (* (* (log y) x) (log t)) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))
#s(approx (+ (pow z 3) (pow y 3)) (pow.f64 y #s(literal 3 binary64)))
#s(approx (+ (pow z 3) (pow y 3)) (*.f64 (pow.f64 y #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 z y) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) y) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) y) (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (neg.f64 (log.f64 y))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))) (*.f64 y y)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 t) (neg.f64 (log.f64 y))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))) z) y))))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) z) y))))))
#s(approx (- (* x (log y)) y) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) y))))))
#s(approx (* (+ (* (neg x) (/ (neg (log y)) y)) -1) y) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) y))))))
#s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (-.f64 (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) y) #s(literal 1 binary64)))
#s(approx (/ (neg (log y)) y) (*.f64 #s(literal -1 binary64) (/.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))) y)))
#s(approx (neg (log y)) (*.f64 #s(literal -1 binary64) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))
#s(approx (log y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))) z) y))))))
#s(approx (* (log y) x) (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))) z) y))))))
#s(approx (- (- (log t) y) z) (*.f64 #s(literal -1 binary64) (*.f64 y (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (log.f64 t) z) y))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) z) #s(literal 1 binary64))) y))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 #s(literal -1 binary64) (*.f64 y (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) z) #s(literal 1 binary64)) y) (pow.f64 z #s(literal -1 binary64))))))
#s(approx (* (/ (log y) z) x) (/.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) z))
#s(approx (/ (log y) z) (/.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) y))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) z) y))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) (fma.f64 z (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) z) (*.f64 z z))) y) (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))) z) y))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 y (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) (fma.f64 z (-.f64 (/.f64 (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) (fma.f64 z (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) z) (*.f64 z z))) (fma.f64 (*.f64 z z) (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) z) (pow.f64 z #s(literal 3 binary64))))) y) (/.f64 (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))) (fma.f64 z (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) z) (*.f64 z z))) y) (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))) z) y))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) y) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))) y) (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) y) (*.f64 z (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))
#s(approx (pow (* (log y) x) 3) (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 3 binary64)))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 y y) (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z z) y) (*.f64 #s(literal 1 binary64) z)) y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) (pow.f64 y #s(literal 3 binary64))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))
#s(approx (pow (* (log y) x) 2) (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))
#s(approx (* (* (log y) x) (log t)) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))
#s(approx (+ (pow z 3) (pow y 3)) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 z y) #s(literal 3 binary64))) #s(literal 1 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))) y) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))))))) y) (+.f64 (pow.f64 (*.f64 x (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64))))) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 x (*.f64 (log.f64 t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) y) #s(literal -1 binary64)))))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y)))) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 x (log.f64 y)) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y))) y))
#s(approx z z)
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y)))) y))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 t) (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y)))) y))
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) y))
#s(approx (- (- (log t) y) z) (-.f64 (-.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) z)) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (-.f64 (*.f64 x (log.f64 y)) y))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (-.f64 (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y))) y))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (-.f64 (*.f64 x (log.f64 y)) y) z))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) z (*.f64 x (log.f64 y))) y) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 z (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) y))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 z (-.f64 (pow.f64 y #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) y))))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) y))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (-.f64 (fma.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 z (-.f64 (fma.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 5 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (/.f64 x (*.f64 y y)) (/.f64 (*.f64 (log.f64 t) (log.f64 y)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 y #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) y))) y) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))))) (pow.f64 y #s(literal -1 binary64))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) y))))) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) y))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 z (fma.f64 #s(literal -1 binary64) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (-.f64 (fma.f64 z (fma.f64 #s(literal -1 binary64) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z (fma.f64 z (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 z (fma.f64 #s(literal -1 binary64) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (fma.f64 #s(literal -1 binary64) (*.f64 y z) (*.f64 y y)))
#s(approx (+ (* z z) (- (* y y) (* z y))) (fma.f64 z (-.f64 z y) (*.f64 y y)))
#s(approx (- (* y y) (* z y)) (fma.f64 #s(literal -1 binary64) (*.f64 y z) (*.f64 y y)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (pow z 3) (pow.f64 z #s(literal 3 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (fma.f64 z (fma.f64 #s(literal -1 binary64) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(literal -1 binary64) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 z (-.f64 (/.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) z))
#s(approx (- (- (* x (log y)) y) z) (*.f64 z (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 #s(literal -1 binary64) z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 z (-.f64 (/.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 #s(literal -1 binary64) z))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 z (-.f64 (/.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (- (- (log t) y) z) (*.f64 #s(literal -1 binary64) z))
#s(approx (- (- (log t) y) z) (*.f64 z (-.f64 (/.f64 (log.f64 t) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) z))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 z (-.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 y z)))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) #s(literal -1 binary64))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (*.f64 z (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 z (-.f64 (+.f64 (/.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 y z) (/.f64 (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 y (*.f64 z z)) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (+.f64 (/.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 y z) (/.f64 (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (*.f64 z z)) (+.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (fma.f64 (/.f64 (*.f64 y y) (*.f64 z z)) (/.f64 (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 z (-.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 y (*.f64 z z)) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (+.f64 (/.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (+.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 (/.f64 (*.f64 y y) (pow.f64 z #s(literal 3 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (*.f64 z (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 #s(literal -1 binary64) (*.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (/.f64 (*.f64 (*.f64 y y) (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (pow.f64 z #s(literal 3 binary64))) (fma.f64 #s(literal -1 binary64) (*.f64 (/.f64 y z) (/.f64 (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (*.f64 z z)) (+.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (fma.f64 (/.f64 (*.f64 y y) (*.f64 z z)) (/.f64 (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (+.f64 (/.f64 (*.f64 (*.f64 y y) (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 y z) #s(literal 3 binary64)) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (*.f64 x (*.f64 (log.f64 t) (log.f64 y))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (fma.f64 x (*.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z)) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z z)) (fma.f64 x (*.f64 (log.f64 t) (log.f64 y)) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z z)) (fma.f64 x (*.f64 (log.f64 t) (log.f64 y)) (+.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) z) (+.f64 (/.f64 (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (pow.f64 z #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) z))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (pow.f64 z #s(literal 3 binary64))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (+.f64 (/.f64 (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 z z)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 z z) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 y z)))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 z z) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y y) (*.f64 z z))) (/.f64 y z))))
#s(approx (- (* y y) (* z y)) (*.f64 z (-.f64 (/.f64 (*.f64 y y) z) y)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (pow.f64 z #s(literal 3 binary64))) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (+ (pow z 3) (pow y 3)) (*.f64 (pow.f64 z #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 y z) #s(literal 3 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (*.f64 z z)) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y) z))))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 x (log.f64 y)) y) z))))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y) z))))))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (+.f64 (log.f64 t) (*.f64 x (log.f64 y))) y) z))))))
#s(approx (- (- (log t) y) z) (*.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (log.f64 t) y) z))))))
#s(approx (* (- (+ (* x (/ (log y) z)) -1) (/ y z)) z) (*.f64 #s(literal -1 binary64) (*.f64 z (-.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 x (log.f64 y)) z))) (*.f64 #s(literal -1 binary64) (/.f64 y z))))))
#s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (*.f64 x (log.f64 y)) (*.f64 #s(literal 1 binary64) y)) z)) #s(literal 1 binary64)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) z))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) y) z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (fma.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) y) (*.f64 y y))) z) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) y) z))))))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (*.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (fma.f64 y (-.f64 (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (fma.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) y) (*.f64 y y))) (fma.f64 (*.f64 y y) (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) y) (pow.f64 y #s(literal 3 binary64))))) z) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (fma.f64 y (-.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) y) (*.f64 y y))) z) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) y) z))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (*.f64 (neg.f64 (pow.f64 y #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) z) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 y y) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) z) (*.f64 y (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
#s(approx (+ (* z z) (- (* y y) (* z y))) (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y y) z) (*.f64 #s(literal 1 binary64) y)) z)))))
#s(approx (- (* y y) (* z y)) (*.f64 #s(literal -1 binary64) (*.f64 z (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 y y) z) (*.f64 #s(literal 1 binary64) y)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 #s(literal -1 binary64) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) (pow.f64 z #s(literal 3 binary64))))))))
#s(approx (+ (pow z 3) (pow y 3)) (*.f64 #s(literal -1 binary64) (*.f64 (pow.f64 z #s(literal 3 binary64)) (-.f64 (*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 y z) #s(literal 3 binary64))) #s(literal 1 binary64)))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (*.f64 z z) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 y y) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))) z) (*.f64 y (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) z) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (log t) (log.f64 t))
#s(approx t t)
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) (+.f64 y z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (pow (log t) 3) (pow.f64 (log.f64 t) #s(literal 3 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y))))))
#s(approx (pow (log t) 2) (pow.f64 (log.f64 t) #s(literal 2 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 t) (log.f64 y)))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (log t) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (*.f64 x (log.f64 y))) (+.f64 y z)))
#s(approx (- (- (log t) y) z) (-.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t))) (+.f64 y z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (fma.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (fma.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))
#s(approx (pow (log t) 3) (*.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 3 binary64))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (-.f64 (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))))
#s(approx (pow (log t) 2) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64)))
#s(approx (* (* (log y) x) (log t)) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 t)) #s(literal 2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 x (*.f64 (log.f64 y) (neg.f64 (log.f64 t)))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) t)) (*.f64 x (log.f64 y)))) (+.f64 y z)))
#s(approx (log t) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (-.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) t)) (*.f64 x (log.f64 y)))) (+.f64 y z)))
#s(approx (+ (* (log y) x) (- (- (log t) y) z)) (-.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) t)) (*.f64 x (log.f64 y)))) (+.f64 y z)))
#s(approx (- (- (log t) y) z) (-.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) (+.f64 y z)))
#s(approx (/ (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y))))) (/.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)))))
#s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z)) (*.f64 (neg.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))))))
#s(approx (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 3 binary64))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))
#s(approx (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 3 binary64))))
#s(approx (pow (log t) 3) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 3 binary64)))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3))) (*.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))))))))
#s(approx (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))))
#s(approx (- (pow (log t) 2) (* (* (log y) x) (log t))) (-.f64 (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64)) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))))
#s(approx (pow (log t) 2) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64)))
#s(approx (* (* (log y) x) (log t)) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))))))
#s(approx (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (* z z) (- (* y y) (* z y)))) (*.f64 (-.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64)))) #s(literal 2 binary64))) (*.f64 x (*.f64 (log.f64 y) (+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) t) #s(literal -1 binary64))))))) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))

eval99.0ms (2.4%)

Memory
23.2MiB live, 210.3MiB allocated; 19ms collecting garbage
Compiler

Compiled 67 687 to 3 365 computations (95% saved)

prune21.0ms (0.5%)

Memory
9.6MiB live, 56.6MiB allocated; 1ms collecting garbage
Pruning

14 alts after pruning (5 fresh and 9 done)

PrunedKeptTotal
New7823785
Fresh123
Picked235
Done066
Total78514799
Accuracy
100.0%
Counts
799 → 14
Alt Table
Click to see full alt table
StatusAccuracyProgram
64.8%
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
✓54.9%
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
5.1%
(/.f64 #s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
✓88.9%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
70.3%
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
67.7%
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 3 binary64)) #s(literal -1 binary64)) (fma.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal -1 binary64))))) y)) z) (log.f64 t))
64.7%
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 #s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (/.f64 (*.f64 x (log.f64 y)) y)) y)) z) (log.f64 t))
✓41.7%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
✓32.4%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
✓46.6%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
✓36.3%
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
✓31.2%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
✓35.7%
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
✓25.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Compiler

Compiled 1 111 to 429 computations (61.4% saved)

regimes66.0ms (1.6%)

Memory
-26.0MiB live, 120.2MiB allocated; 8ms collecting garbage
Counts
28 → 1
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) y)) (log.f64 t))
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 #s(approx (- (+ (* x (/ (log y) z)) -1) (/ y z)) (*.f64 (/.f64 (log.f64 y) z) x)) z)) (log.f64 t))
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 #s(approx (+ (* (neg x) (/ (neg (log y)) y)) -1) (/.f64 (*.f64 x (log.f64 y)) y)) y)) z) (log.f64 t))
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) #s(literal -1 binary64)) y)) z) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal -1 binary64)) (/.f64 y z)) z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 y)) x (log.f64 t)) y) (-.f64 (/.f64 z y) #s(literal -1 binary64))) y))
(+.f64 (-.f64 #s(approx (- (* x (log y)) y) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 3 binary64)) #s(literal -1 binary64)) (fma.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal -1 binary64))))) y)) z) (log.f64 t))
(/.f64 #s(approx (- (* (+ (pow (* (log y) x) 3) (pow (log t) 3)) (+ (* z z) (- (* y y) (* z y)))) (* (+ (pow (* (log y) x) 2) (- (pow (log t) 2) (* (* (log y) x) (log t)))) (+ (pow z 3) (pow y 3)))) (*.f64 (pow.f64 x #s(literal 3 binary64)) (*.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (-.f64 (fma.f64 y y (*.f64 z z)) (*.f64 y z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 y) x) (log.f64 t)))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 z y)))))
(/.f64 (-.f64 (*.f64 (+.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (*.f64 (fma.f64 (log.f64 t) (log.f64 t) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (log.f64 t) (*.f64 (log.f64 y) x)))) (fma.f64 y y (fma.f64 z z (*.f64 (neg.f64 y) z)))))
Outputs
(fma.f64 (log.f64 y) x (-.f64 (-.f64 (log.f64 t) y) z))
Calls

8 calls:

9.0ms
t
9.0ms
x
9.0ms
(log.f64 t)
7.0ms
z
7.0ms
y
Results
AccuracySegmentsBranch
99.9%1(log.f64 t)
99.9%1(-.f64 (*.f64 x (log.f64 y)) y)
99.9%1(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
99.9%1(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
99.9%1x
99.9%1y
99.9%1z
99.9%1t
Compiler

Compiled 31 to 46 computations (-48.4% saved)

regimes42.0ms (1%)

Memory
-13.0MiB live, 85.3MiB allocated; 5ms collecting garbage
Counts
16 → 1
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
Outputs
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (+.f64 z y))
Calls

8 calls:

7.0ms
(log.f64 t)
6.0ms
y
5.0ms
t
5.0ms
z
5.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Results
AccuracySegmentsBranch
99.9%1(log.f64 t)
99.9%1(-.f64 (*.f64 x (log.f64 y)) y)
99.9%1(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
99.9%1(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
99.9%1x
99.9%1y
99.9%1z
99.9%1t
Compiler

Compiled 31 to 46 computations (-48.4% saved)

regimes38.0ms (0.9%)

Memory
40.3MiB live, 86.3MiB allocated; 2ms collecting garbage
Counts
15 → 2
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
Calls

8 calls:

6.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
5.0ms
t
5.0ms
(log.f64 t)
4.0ms
z
4.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
Results
AccuracySegmentsBranch
88.9%1(log.f64 t)
99.6%2(-.f64 (*.f64 x (log.f64 y)) y)
99.5%2(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
99.5%2(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
99.6%3x
99.7%2y
99.5%3z
88.9%1t
Compiler

Compiled 31 to 46 computations (-48.4% saved)

regimes25.0ms (0.6%)

Memory
4.5MiB live, 50.1MiB allocated; 4ms collecting garbage
Counts
14 → 3
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (*.f64 (log.f64 y) x)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
Outputs
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (*.f64 (log.f64 y) x)) (+.f64 z y))
Calls

5 calls:

8.0ms
y
4.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
4.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
4.0ms
x
4.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
Results
AccuracySegmentsBranch
99.6%3x
99.6%3(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
99.6%3(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
99.6%3(-.f64 (*.f64 x (log.f64 y)) y)
88.9%1y
Compiler

Compiled 27 to 33 computations (-22.2% saved)

regimes28.0ms (0.7%)

Memory
-52.0MiB live, 53.9MiB allocated; 14ms collecting garbage
Counts
11 → 3
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
Outputs
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 z)))
Calls

5 calls:

9.0ms
z
7.0ms
x
4.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
4.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
3.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
Results
AccuracySegmentsBranch
81.3%3z
89.8%3(-.f64 (*.f64 x (log.f64 y)) y)
86.7%3(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
86.7%3(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
93.8%3x
Compiler

Compiled 27 to 33 computations (-22.2% saved)

regimes4.0ms (0.1%)

Memory
8.4MiB live, 8.4MiB allocated; 0ms collecting garbage
Counts
10 → 3
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
Outputs
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(fma.f64 (log.f64 y) x #s(approx (- (- (log t) y) z) (neg.f64 y)))
Calls

1 calls:

3.0ms
x
Results
AccuracySegmentsBranch
93.5%3x
Compiler

Compiled 1 to 4 computations (-300% saved)

regimes17.0ms (0.4%)

Memory
-12.2MiB live, 35.5MiB allocated; 0ms collecting garbage
Counts
9 → 3
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (+.f64 z y))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Calls

5 calls:

3.0ms
(log.f64 t)
3.0ms
t
3.0ms
x
3.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
3.0ms
y
Results
AccuracySegmentsBranch
84.3%3(-.f64 (*.f64 x (log.f64 y)) y)
70.3%1(log.f64 t)
70.3%1y
70.3%1t
87.6%3x
Compiler

Compiled 11 to 24 computations (-118.2% saved)

regimes22.0ms (0.6%)

Memory
10.2MiB live, 57.1MiB allocated; 2ms collecting garbage
Counts
7 → 4
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 z)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Calls

8 calls:

3.0ms
t
3.0ms
x
3.0ms
(log.f64 t)
3.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
3.0ms
z
Results
AccuracySegmentsBranch
50.2%3(log.f64 t)
50.2%3t
59.4%2y
62.0%4z
72.1%4(-.f64 (*.f64 x (log.f64 y)) y)
57.3%4(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
57.3%4(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
71.7%4x
Compiler

Compiled 31 to 46 computations (-48.4% saved)

regimes7.0ms (0.2%)

Memory
16.7MiB live, 16.7MiB allocated; 0ms collecting garbage
Counts
6 → 4
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
(+.f64 #s(approx (- (- (* x (log y)) y) z) (neg.f64 y)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Calls

3 calls:

2.0ms
x
2.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
2.0ms
y
Results
AccuracySegmentsBranch
53.0%4y
62.3%4x
61.3%4(-.f64 (*.f64 x (log.f64 y)) y)
Compiler

Compiled 8 to 15 computations (-87.5% saved)

regimes8.0ms (0.2%)

Memory
-20.1MiB live, 25.8MiB allocated; 2ms collecting garbage
Counts
5 → 4
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (*.f64 (log.f64 y) x))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Calls

3 calls:

4.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
2.0ms
z
2.0ms
x
Results
AccuracySegmentsBranch
61.3%4(-.f64 (*.f64 x (log.f64 y)) y)
55.7%3z
60.9%4x
Compiler

Compiled 8 to 15 computations (-87.5% saved)

regimes13.0ms (0.3%)

Memory
28.7MiB live, 28.7MiB allocated; 0ms collecting garbage
Counts
3 → 2
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (- (+ (* (log y) x) (log t)) (+ z y)) (neg.f64 z))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Calls

8 calls:

2.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
2.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
2.0ms
(log.f64 t)
2.0ms
x
2.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
Results
AccuracySegmentsBranch
39.0%3(log.f64 t)
39.0%3t
48.5%2y
42.4%2(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
42.4%2(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
49.9%3z
39.6%2x
47.3%2(-.f64 (*.f64 x (log.f64 y)) y)
Compiler

Compiled 31 to 46 computations (-48.4% saved)

regimes11.0ms (0.3%)

Memory
-28.0MiB live, 24.2MiB allocated; 3ms collecting garbage
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
Calls

8 calls:

3.0ms
x
1.0ms
t
1.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
1.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
1.0ms
(log.f64 t)
Results
AccuracySegmentsBranch
25.9%1(log.f64 t)
25.9%1t
25.9%1x
25.9%1(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
25.9%1(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
25.9%1(-.f64 (*.f64 x (log.f64 y)) y)
25.9%1z
25.9%1y
Compiler

Compiled 31 to 46 computations (-48.4% saved)

bsearch12.0ms (0.3%)

Memory
23.4MiB live, 23.4MiB allocated; 0ms collecting garbage
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
11.0ms
2.2728302723499294e-16
6.966521822073379e-15
Samples
7.0ms112×0valid
Compiler

Compiled 266 to 227 computations (14.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 4.0ms
ival-log: 2.0ms (54.7% of total)
ival-mult!: 1.0ms (27.4% of total)
ival-sub!: 0.0ms (0% of total)
adjust: 0.0ms (0% of total)
ival-add!: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory
1.6MiB live, 1.6MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
37.66899400764023
2.2251711724618797e+52
0.0ms
-3.4746119903681934e+23
-9.758299175118078e+19
Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch39.0ms (1%)

Memory
3.8MiB live, 49.5MiB allocated; 2ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
12.0ms
1.0478192982109646e+70
1.9326712395071296e+73
25.0ms
-29589295585936454000.0
-1796133636732514800.0
Samples
28.0ms240×0valid
Compiler

Compiled 479 to 422 computations (11.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 8.0ms
ival-log: 5.0ms (63.4% of total)
ival-sub!: 1.0ms (12.7% of total)
ival-mult!: 1.0ms (12.7% of total)
adjust: 0.0ms (0% of total)
ival-add!: 0.0ms (0% of total)

bsearch25.0ms (0.6%)

Memory
-16.4MiB live, 29.0MiB allocated; 5ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
23.0ms
4.185999330409069e+28
1.101245027614494e+38
1.0ms
-29589295585936454000.0
-1796133636732514800.0
Samples
18.0ms144×0valid
Compiler

Compiled 510 to 449 computations (12% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-log: 12.0ms (87% of total)
ival-sub!: 1.0ms (7.3% of total)
ival-mult!: 1.0ms (7.3% of total)
adjust: 0.0ms (0% of total)
ival-add!: 0.0ms (0% of total)

bsearch17.0ms (0.4%)

Memory
25.4MiB live, 25.4MiB allocated; 0ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
9.0ms
1.0478192982109646e+70
1.9326712395071296e+73
6.0ms
-1.2679593809235462e+97
-7.434038330533734e+96
Samples
9.0ms160×0valid
Compiler

Compiled 422 to 365 computations (13.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 5.0ms
ival-log: 3.0ms (57.8% of total)
ival-sub!: 1.0ms (19.3% of total)
ival-mult!: 1.0ms (19.3% of total)
adjust: 0.0ms (0% of total)
ival-add!: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory
1.8MiB live, 1.8MiB allocated; 0ms collecting garbage
Algorithm
3×left-value
Steps
TimeLeftRight
0.0ms
37.66899400764023
2.2251711724618797e+52
0.0ms
-1.5196381833154176e+177
-7.874589380095801e+170
0.0ms
-1.41642052954534e+305
-2.710109277368603e+302
Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch32.0ms (0.8%)

Memory
-39.4MiB live, 57.8MiB allocated; 8ms collecting garbage
Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
12.0ms
4.185999330409069e+28
1.101245027614494e+38
8.0ms
-3.365416752399672e-136
-8.54892396815909e-137
7.0ms
-1.2679593809235462e+97
-7.434038330533734e+96
Samples
17.0ms256×0valid
Compiler

Compiled 544 to 498 computations (8.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 8.0ms
ival-log: 5.0ms (59.2% of total)
ival-sub!: 1.0ms (11.8% of total)
ival-add!: 1.0ms (11.8% of total)
ival-mult!: 1.0ms (11.8% of total)
adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory
2.9MiB live, 2.9MiB allocated; 0ms collecting garbage
Algorithm
3×left-value
Steps
TimeLeftRight
0.0ms
3.3178083626231963e-6
37.66899400764023
0.0ms
-1.5196381833154176e+177
-7.874589380095801e+170
0.0ms
-1.41642052954534e+305
-2.710109277368603e+302
Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch10.0ms (0.3%)

Memory
20.7MiB live, 20.7MiB allocated; 0ms collecting garbage
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
9.0ms
4.335764421602864e+109
4.547259284107536e+110
Samples
6.0ms96×0valid
Compiler

Compiled 182 to 173 computations (4.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 3.0ms
ival-log: 2.0ms (64.4% of total)
ival-mult!: 1.0ms (32.2% of total)
ival-sub!: 0.0ms (0% of total)
adjust: 0.0ms (0% of total)
ival-add!: 0.0ms (0% of total)

derivations323.0ms (7.9%)

Memory
-22.1MiB live, 359.9MiB allocated; 25ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 582 to 92 computations (84.2% saved)

preprocess55.0ms (1.3%)

Memory
47.4MiB live, 138.7MiB allocated; 8ms collecting garbage
Compiler

Compiled 1 186 to 204 computations (82.8% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...