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

Time bar (total: 4.1s)

start0.0ms (0%)

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

analyze2.0ms (0%)

Memory
3.6MiB live, 3.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.7%)

Memory
-16.0MiB live, 1 342.8MiB allocated; 314ms collecting garbage
Samples
727.0ms8 255×0valid
0.0ms1×2valid
Precisions
Click to see histograms. Total time spent on operations: 504.0ms
ival-log: 370.0ms (73.4% of total)
ival-sub!: 71.0ms (14.1% of total)
ival-mult!: 45.0ms (8.9% of total)
ival-add!: 17.0ms (3.4% of total)
adjust: 2.0ms (0.4% of total)
Bogosity

preprocess52.0ms (1.3%)

Memory
1.7MiB live, 47.2MiB allocated; 8ms collecting garbage
Iterations

Useful iterations: 3 (0.0ms)

IterNodesCost
055174
1226165
2956152
33192150
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Symmetry

(abs t)

Compiler

Compiled 20 to 20 computations (0% saved)

series176.0ms (4.3%)

Memory
23.9MiB live, 267.9MiB allocated; 48ms collecting garbage
Counts
10 → 46
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) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#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) (* -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 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z 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 (- (+ (* -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 (* 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
45.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)
35.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)
19.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)
15.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)
14.0ms
x
@-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)

rewrite67.0ms (1.6%)

Memory
-13.6MiB live, 76.4MiB allocated; 9ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0181899
0189831
01289805
13657805
Stop Event
1×saturated
1×iter-limit
1×node-limit
1×iter-limit
Counts
56 → 89
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) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#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) (* -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 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z 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 (- (+ (* -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 (* 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
(neg.f64 (-.f64 z (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)))
(neg.f64 (-.f64 (+.f64 z y) (fma.f64 (log.f64 y) x (log.f64 t))))
(-.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 (*.f64 (log.f64 y) x) y) z) (neg.f64 (log.f64 t)))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(+.f64 (-.f64 (log.f64 t) y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (neg.f64 z))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (neg.f64 (+.f64 z y)))
(+.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))
(neg.f64 (-.f64 z (-.f64 (*.f64 (log.f64 y) x) y)))
(neg.f64 (-.f64 (+.f64 z y) (*.f64 (log.f64 y) x)))
(fma.f64 #s(literal -1 binary64) y (-.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y)))
(fma.f64 y #s(literal -1 binary64) (-.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 x (log.f64 y) (neg.f64 (+.f64 z y)))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)
(-.f64 (*.f64 (log.f64 y) x) (+.f64 z y))
(+.f64 (neg.f64 y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (neg.f64 z))
(+.f64 (*.f64 (log.f64 y) x) (neg.f64 (+.f64 z y)))
(neg.f64 (-.f64 y (*.f64 (log.f64 y) x)))
(fma.f64 #s(literal -1 binary64) y (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (neg.f64 y))
(fma.f64 y #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(fma.f64 x (log.f64 y) (neg.f64 y))
(-.f64 (neg.f64 y) (*.f64 (neg.f64 x) (log.f64 y)))
(-.f64 (neg.f64 y) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (*.f64 (log.f64 y) x) y)
(+.f64 (neg.f64 y) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (neg.f64 y))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
x
(log.f64 (fabs.f64 y))
(log.f64 y)
y
z
(log.f64 (fabs.f64 t))
(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 (+.f64 (log.f64 y) (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) x))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (+.f64 (neg.f64 (/.f64 (+.f64 z y) x)) (log.f64 y)) x))
#s(approx (- (* x (log y)) y) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (log.f64 y)) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (- (- (* x (log y)) y) z) (neg.f64 (*.f64 (+.f64 (neg.f64 (log.f64 y)) (/.f64 (+.f64 z y) x)) x)))
#s(approx (- (* x (log y)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (log.f64 y)) (/.f64 y x)) 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 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (*.f64 (log.f64 y) x) z))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (- (* x (log y)) y) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (-.f64 (-.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (- (* x (log y)) y) (*.f64 (-.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))) #s(literal 1 binary64)) y))
#s(approx (* x (log y)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z) y)) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x) z) y)) #s(literal 1 binary64))))
#s(approx (- (* x (log y)) y) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y))) #s(literal 1 binary64))))
#s(approx (* x (log y)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x))
#s(approx (log y) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 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 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y))
#s(approx (- (- (* x (log y)) y) z) (-.f64 (-.f64 (*.f64 (log.f64 y) x) 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) (*.f64 (-.f64 (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) #s(literal 1 binary64)) (/.f64 y z)) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
#s(approx (- (- (* x (log y)) y) z) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)) #s(literal 1 binary64))))
#s(approx (log t) (log.f64 t))
#s(approx t t)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y) z))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y) z))
#s(approx (log t) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)))

eval7.0ms (0.2%)

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

Compiled 685 to 305 computations (55.5% saved)

prune33.0ms (0.8%)

Memory
-12.8MiB live, 23.2MiB allocated; 18ms collecting garbage
Pruning

8 alts after pruning (8 fresh and 0 done)

PrunedKeptTotal
New71879
Fresh000
Picked101
Done000
Total72880
Accuracy
99.9%
Counts
80 → 8
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y))) (log.f64 t))
▶99.9%
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
72.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
▶67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
72.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
▶77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
78.1%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
▶33.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
Compiler

Compiled 242 to 242 computations (0% saved)

series236.0ms (5.7%)

Memory
20.5MiB live, 311.6MiB allocated; 76ms collecting garbage
Counts
31 → 136
Calls
Call 1
Inputs
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y))) (log.f64 t))
(fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y)))
(log.f64 y)
y
x
(neg.f64 (+.f64 z y))
(+.f64 z y)
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
(neg.f64 z)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(fma.f64 (log.f64 y) x (log.f64 t))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
(-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)
(fma.f64 (log.f64 y) x (neg.f64 y))
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))))
(/.f64 (log.f64 t) y)
(neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))
(*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))
(/.f64 (neg.f64 (log.f64 y)) y)
(neg.f64 (log.f64 y))
#s(literal 1 binary64)
(/.f64 z y)
Outputs
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (* 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 x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#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) (neg y)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* x (log y)) (* y (- (/ (log t) y) (+ 1 (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ z y)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) (+ 1 (/ z y)))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (log t) y)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (+ (/ (log t) y) (/ (* x (log y)) y))))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (* -1 (/ (* x (log y)) y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* x (+ (log y) (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (+ (/ 1 x) (/ z (* x y))))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* x (- (/ (log t) (* x y)) (* -1 (/ (log y) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y 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) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) (+ 1 (/ z y))) x)) (/ (log y) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) 1) x)) (/ (log y) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log t) (* x y))) (/ (log y) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -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 (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (neg (+ z y)) #s(hole binary64 (- (* -1 y) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (log t) (+ z (* -1 (* x (log y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (log t) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (log t) (* -1 (* x (log y)))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (* -1 (* 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 (/ z y) #s(hole binary64 (/ z y)))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z 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) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (neg (+ z y)) #s(hole binary64 (* y (- (* -1 (/ z y)) 1))))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 -1))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ (* x (log (/ 1 y))) y)))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (- (log t) (* x (log (/ 1 y)))) y)))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) y))))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (/ (* x (log (/ 1 y))) y)))
#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) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* 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) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (neg (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (/ z y))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) 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) (neg y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* y (- (+ 1 (* -1 (/ (log t) y))) (+ (* -1 (/ z y)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (+ (* -1 z) (* x (+ (log -1) (* -1 (log (/ -1 y))))))) y)) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y))))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y))))
#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) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (neg (+ z y)) #s(hole binary64 (- (* -1 z) y)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* -1 z) (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ z y)) (/ (log t) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (neg (+ z y)) #s(hole binary64 (* z (- (* -1 (/ y z)) 1))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* z (- (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z) 1))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (/ z y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* z (- (/ (log t) (* y z)) (+ (* -1 (/ (* x (log y)) (* y z))) (+ (/ 1 y) (/ 1 z)))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* 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 (neg (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))) z)) (/ 1 y))))))
#s(approx t #s(hole binary64 t))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (/ (log t) y) (* -1 (/ (* x (log y)) y)))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (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)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (* -1 (/ (log (/ 1 t)) y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (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)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) y)))
Calls

12 calls:

TimeVariablePointExpression
43.0ms
t
@-inf
((+ (+ (* (log y) x) (neg (+ z y))) (log t)) (+ (* (log y) x) (neg (+ z y))) (log y) y x (neg (+ z y)) (+ z y) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (+ (* (log y) x) (neg y)) z) (log t)) (- (+ (* (log y) x) (neg y)) z) (+ (* (log y) x) (neg y)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (neg (* x (/ (neg (log y)) y))) (* x (/ (neg (log y)) y)) (/ (neg (log y)) y) (neg (log y)) 1 (/ z y))
35.0ms
y
@0
((+ (+ (* (log y) x) (neg (+ z y))) (log t)) (+ (* (log y) x) (neg (+ z y))) (log y) y x (neg (+ z y)) (+ z y) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (+ (* (log y) x) (neg y)) z) (log t)) (- (+ (* (log y) x) (neg y)) z) (+ (* (log y) x) (neg y)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (neg (* x (/ (neg (log y)) y))) (* x (/ (neg (log y)) y)) (/ (neg (log y)) y) (neg (log y)) 1 (/ z y))
28.0ms
x
@inf
((+ (+ (* (log y) x) (neg (+ z y))) (log t)) (+ (* (log y) x) (neg (+ z y))) (log y) y x (neg (+ z y)) (+ z y) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (+ (* (log y) x) (neg y)) z) (log t)) (- (+ (* (log y) x) (neg y)) z) (+ (* (log y) x) (neg y)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (neg (* x (/ (neg (log y)) y))) (* x (/ (neg (log y)) y)) (/ (neg (log y)) y) (neg (log y)) 1 (/ z y))
28.0ms
y
@-inf
((+ (+ (* (log y) x) (neg (+ z y))) (log t)) (+ (* (log y) x) (neg (+ z y))) (log y) y x (neg (+ z y)) (+ z y) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (+ (* (log y) x) (neg y)) z) (log t)) (- (+ (* (log y) x) (neg y)) z) (+ (* (log y) x) (neg y)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (neg (* x (/ (neg (log y)) y))) (* x (/ (neg (log y)) y)) (/ (neg (log y)) y) (neg (log y)) 1 (/ z y))
27.0ms
y
@inf
((+ (+ (* (log y) x) (neg (+ z y))) (log t)) (+ (* (log y) x) (neg (+ z y))) (log y) y x (neg (+ z y)) (+ z y) z (log t) t (+ (- (- (* x (log y)) y) z) (log t)) (neg z) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (+ (* (log y) x) (neg y)) z) (log t)) (- (+ (* (log y) x) (neg y)) z) (+ (* (log y) x) (neg y)) (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (neg (* x (/ (neg (log y)) y))) (* x (/ (neg (log y)) y)) (/ (neg (log y)) y) (neg (log y)) 1 (/ z y))

rewrite121.0ms (3%)

Memory
0.5MiB live, 91.1MiB allocated; 12ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
04763635
05223178
033733161
192253161
Stop Event
1×saturated
1×iter-limit
1×node-limit
1×iter-limit
Counts
167 → 332
Calls
Call 1
Inputs
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y))) (log.f64 t))
(fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y)))
(log.f64 y)
y
x
(neg.f64 (+.f64 z y))
(+.f64 z y)
z
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
(neg.f64 z)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(fma.f64 (log.f64 y) x (log.f64 t))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
(-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z)
(fma.f64 (log.f64 y) x (neg.f64 y))
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))))
(/.f64 (log.f64 t) y)
(neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))
(*.f64 x (/.f64 (neg.f64 (log.f64 y)) y))
(/.f64 (neg.f64 (log.f64 y)) y)
(neg.f64 (log.f64 y))
#s(literal 1 binary64)
(/.f64 z y)
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (log t) (+ y z))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (* 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 x #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#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) (neg y)) #s(hole binary64 (* -1 y)))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (- (* x (log y)) y)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* x (log y)) (* y (- (/ (log t) y) (+ 1 (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ z y)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) (+ 1 (/ z y)))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (log t) y)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (+ (/ (log t) y) (/ (* x (log y)) y))))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (* -1 (/ (* x (log y)) y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (+ (/ y x) (/ z x))))))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (* x (+ (log y) (* -1 (/ (+ y z) x))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* x (+ (log y) (* -1 (/ y x))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* x (+ (log y) (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (+ (/ 1 x) (/ z (* x y))))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* x (- (/ (log t) (* x y)) (* -1 (/ (log y) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) (+ y 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) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ y x))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) (+ 1 (/ z y))) x)) (/ (log y) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) 1) x)) (/ (log y) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log t) (* x y))) (/ (log y) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (* x (log y))) z)))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -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 (+ z y)) #s(hole binary64 (* -1 z)))
#s(approx (neg (+ z y)) #s(hole binary64 (- (* -1 y) z)))
#s(approx (+ z y) #s(hole binary64 z))
#s(approx (+ z y) #s(hole binary64 (+ y z)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (+ (* -1 y) (* x (log y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (log t) (+ z (* -1 (* x (log y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (log t) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (log t) (* -1 (* x (log y)))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (* -1 (* 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 (/ z y) #s(hole binary64 (/ z y)))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) (+ 1 (/ z 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) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (neg (+ z y)) #s(hole binary64 (* y (- (* -1 (/ z y)) 1))))
#s(approx (+ z y) #s(hole binary64 (* y (+ 1 (/ z y)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ (* (log y) x) (neg y)) #s(hole binary64 (* y (- (* -1 (/ (* x (log (/ 1 y))) y)) 1))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 -1))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ (* x (log (/ 1 y))) y)))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (- (log t) (* x (log (/ 1 y)))) y)))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) y))))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (/ (* x (log (/ 1 y))) y)))
#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) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (- (+ (log t) (* 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) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (neg (+ z y)) #s(hole binary64 (* -1 (* y (+ 1 (/ z y))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* y (- (* -1 (/ z y)) 1)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) 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) (neg y)) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* y (- (+ 1 (* -1 (/ (log t) y))) (+ (* -1 (/ z y)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (+ (* -1 z) (* x (+ (log -1) (* -1 (log (/ -1 y))))))) y)) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y))))
#s(approx (neg (* x (/ (neg (log y)) y))) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))
#s(approx (* x (/ (neg (log y)) y)) #s(hole binary64 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y))))
#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) x) (neg (+ z y))) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (- (+ (* -1 z) (* x (log y))) y)))
#s(approx (neg (+ z y)) #s(hole binary64 (- (* -1 z) y)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* -1 z) (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ z y)) (/ (log t) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* z (- (+ (/ (log t) z) (/ (* x (log y)) z)) (+ 1 (/ y z))))))
#s(approx (+ (* (log y) x) (neg (+ z y))) #s(hole binary64 (* z (- (/ (* x (log y)) z) (+ 1 (/ y z))))))
#s(approx (neg (+ z y)) #s(hole binary64 (* z (- (* -1 (/ y z)) 1))))
#s(approx (+ z y) #s(hole binary64 (* z (+ 1 (/ y z)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* z (- (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z) 1))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (/ z y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* z (- (/ (log t) (* y z)) (+ (* -1 (/ (* x (log y)) (* y z))) (+ (/ 1 y) (/ 1 z)))))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (log t)) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (+ (log t) (* 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 (neg (+ z y)) #s(hole binary64 (* -1 (* z (+ 1 (/ y z))))))
#s(approx (+ z y) #s(hole binary64 (* -1 (* z (- (* -1 (/ y z)) 1)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))) z)) (/ 1 y))))))
#s(approx t #s(hole binary64 t))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (/ (log t) y) (* -1 (/ (* x (log y)) y)))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (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)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (* -1 (/ (log (/ 1 t)) y))))
#s(approx (+ (+ (* (log y) x) (neg (+ z y))) (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)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) y)))
Outputs
(neg.f64 (-.f64 z (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)))
(neg.f64 (-.f64 (+.f64 z y) (fma.f64 (log.f64 y) x (log.f64 t))))
(fma.f64 (log.f64 y) x (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(fma.f64 x (log.f64 y) (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(-.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 (*.f64 (log.f64 y) x) y) z) (neg.f64 (log.f64 t)))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(+.f64 (-.f64 (log.f64 t) y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (neg.f64 z))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (-.f64 (neg.f64 y) z))
(+.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 (log.f64 y) x) (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(neg.f64 (-.f64 (+.f64 z y) (*.f64 (log.f64 y) x)))
(neg.f64 (-.f64 z (-.f64 (*.f64 (log.f64 y) x) y)))
(fma.f64 #s(literal -1 binary64) (+.f64 z y) (*.f64 (log.f64 y) x))
(fma.f64 #s(literal -1 binary64) y (-.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (+.f64 z y) #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (-.f64 (neg.f64 y) z))
(fma.f64 x (log.f64 y) (-.f64 (neg.f64 y) z))
(fma.f64 y #s(literal -1 binary64) (-.f64 (*.f64 (log.f64 y) x) z))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (-.f64 (neg.f64 y) z)))
(-.f64 (*.f64 (log.f64 y) x) (+.f64 z y))
(+.f64 (-.f64 (neg.f64 y) z) (*.f64 (log.f64 y) x))
(+.f64 (neg.f64 y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (neg.f64 z))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (neg.f64 y) z))
(log.f64 (fabs.f64 y))
(log.f64 y)
y
x
(*.f64 #s(literal -1 binary64) (+.f64 z y))
(*.f64 (+.f64 z y) #s(literal -1 binary64))
(neg.f64 (+.f64 z y))
(fma.f64 #s(literal -1 binary64) z (neg.f64 y))
(fma.f64 #s(literal -1 binary64) y (neg.f64 z))
(fma.f64 z #s(literal -1 binary64) (neg.f64 y))
(fma.f64 y #s(literal -1 binary64) (neg.f64 z))
(-.f64 (neg.f64 z) y)
(-.f64 (neg.f64 y) z)
(+.f64 (neg.f64 z) (neg.f64 y))
(+.f64 (neg.f64 y) (neg.f64 z))
(-.f64 z (neg.f64 y))
(-.f64 y (neg.f64 z))
(+.f64 z y)
(+.f64 y z)
z
(log.f64 (fabs.f64 t))
(log.f64 t)
t
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
(*.f64 #s(literal -1 binary64) z)
(*.f64 z #s(literal -1 binary64))
(neg.f64 z)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
(neg.f64 (-.f64 (neg.f64 (*.f64 (log.f64 y) x)) (-.f64 (log.f64 t) y)))
(neg.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))))
(fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y))
(fma.f64 x (log.f64 y) (-.f64 (log.f64 t) y))
(-.f64 (-.f64 (log.f64 t) y) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(-.f64 (log.f64 t) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) y)))
(+.f64 (-.f64 (log.f64 t) y) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 y) x)))
(+.f64 (-.f64 (log.f64 t) y) (neg.f64 (neg.f64 (*.f64 (log.f64 y) x))))
(+.f64 (-.f64 (log.f64 t) y) (*.f64 (log.f64 y) x))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (neg.f64 y))
(+.f64 (log.f64 t) (-.f64 (*.f64 (log.f64 y) x) y))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (log.f64 t))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (log.f64 t) y))
(neg.f64 (-.f64 (neg.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 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y)))
(-.f64 (log.f64 t) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (log.f64 t)))
(+.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 y) x)))
(+.f64 (log.f64 t) (neg.f64 (neg.f64 (*.f64 (log.f64 y) x))))
(+.f64 (log.f64 t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(neg.f64 (-.f64 z (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)))
(neg.f64 (-.f64 (+.f64 z y) (fma.f64 (log.f64 y) x (log.f64 t))))
(fma.f64 (log.f64 y) x (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(fma.f64 x (log.f64 y) (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(-.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 (*.f64 (log.f64 y) x) y) z) (neg.f64 (log.f64 t)))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) (-.f64 z (log.f64 t)))
(+.f64 (-.f64 (log.f64 t) y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (neg.f64 z))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (-.f64 (neg.f64 y) z))
(+.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 (log.f64 y) x) (+.f64 (-.f64 (neg.f64 y) z) (log.f64 t)))
(neg.f64 (-.f64 (+.f64 z y) (*.f64 (log.f64 y) x)))
(neg.f64 (-.f64 z (-.f64 (*.f64 (log.f64 y) x) y)))
(fma.f64 #s(literal -1 binary64) (+.f64 z y) (*.f64 (log.f64 y) x))
(fma.f64 #s(literal -1 binary64) y (-.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (+.f64 z y) #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (-.f64 (neg.f64 y) z))
(fma.f64 x (log.f64 y) (-.f64 (neg.f64 y) z))
(fma.f64 y #s(literal -1 binary64) (-.f64 (*.f64 (log.f64 y) x) z))
(-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (-.f64 (neg.f64 y) z)))
(-.f64 (*.f64 (log.f64 y) x) (+.f64 z y))
(+.f64 (-.f64 (neg.f64 y) z) (*.f64 (log.f64 y) x))
(+.f64 (neg.f64 y) (-.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (neg.f64 z))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (neg.f64 y) z))
(neg.f64 (-.f64 y (*.f64 (log.f64 y) x)))
(fma.f64 #s(literal -1 binary64) y (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (neg.f64 y))
(fma.f64 x (log.f64 y) (neg.f64 y))
(fma.f64 y #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(-.f64 (neg.f64 y) (*.f64 (neg.f64 x) (log.f64 y)))
(-.f64 (neg.f64 y) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (neg.f64 y)))
(-.f64 (*.f64 (log.f64 y) x) y)
(+.f64 (neg.f64 y) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (neg.f64 y))
(*.f64 #s(literal -1 binary64) y)
(*.f64 y #s(literal -1 binary64))
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y)
(*.f64 y (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)))
(neg.f64 (-.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)))
(neg.f64 (-.f64 (/.f64 z y) (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64))))
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y) (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64)))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64)))
(+.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) (-.f64 (/.f64 (log.f64 t) y) (/.f64 z y)))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(+.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 (neg.f64 z) y))
(+.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64)))
(neg.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)))
(neg.f64 (-.f64 (fma.f64 (neg.f64 (/.f64 (log.f64 y) y)) x #s(literal 1 binary64)) (/.f64 (log.f64 t) y)))
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y) #s(literal -1 binary64))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y) (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64))
(-.f64 (/.f64 (log.f64 t) y) (fma.f64 (neg.f64 (/.f64 (log.f64 y) y)) x #s(literal 1 binary64)))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(+.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal -1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)))
(*.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x))) (neg.f64 y))
(/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (/.f64 (log.f64 t) y))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (/.f64 (log.f64 t) y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (/.f64 (log.f64 t) y))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 (log.f64 t) y))
(-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (neg.f64 (/.f64 (log.f64 t) y)))
(-.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)))))
(-.f64 (/.f64 (log.f64 t) y) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 (log.f64 t) y))
(+.f64 (/.f64 (log.f64 t) y) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
(*.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 (log.f64 t)) (neg.f64 y))
(/.f64 (log.f64 t) y)
(*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(*.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) y)
(neg.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(*.f64 (*.f64 (neg.f64 (log.f64 y)) x) (/.f64 #s(literal 1 binary64) y))
(*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x)
(*.f64 x (neg.f64 (/.f64 (log.f64 y) y)))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (neg.f64 y))
(/.f64 (*.f64 (neg.f64 (log.f64 y)) x) y)
(*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))
(*.f64 (/.f64 (log.f64 y) y) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) y))
(/.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))
(*.f64 (log.f64 y) #s(literal -1 binary64))
(neg.f64 (log.f64 y))
(log.f64 (fabs.f64 (/.f64 #s(literal 1 binary64) y)))
(log.f64 (/.f64 #s(literal 1 binary64) y))
#s(literal 1 binary64)
(*.f64 z (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 z) (neg.f64 y))
(/.f64 z y)
#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 (+ (* (log y) x) (neg (+ z y))) (-.f64 (neg.f64 y) z))
#s(approx (+ (* (log y) x) (neg (+ z y))) (-.f64 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx x x)
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (log.f64 t) y))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#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) (neg y)) (neg.f64 y))
#s(approx (+ (* (log y) x) (neg y)) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (fma.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y (*.f64 (log.f64 y) x)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 1 binary64)) (/.f64 z y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 1 binary64)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (neg (* x (/ (neg (log y)) y))) (/.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* x (/ (neg (log y)) y)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)))
#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 (+ (* (log y) x) (neg (+ z y))) (*.f64 (+.f64 (/.f64 (-.f64 (neg.f64 y) z) x) (log.f64 y)) x))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (log.f64 t) y) x)) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (+.f64 (/.f64 (log.f64 t) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) (neg y)) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (log.f64 y)) x))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) x) (log.f64 y)) x))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 x y)) (neg.f64 (/.f64 (log.f64 y) y))) (+.f64 (/.f64 z (*.f64 x y)) (/.f64 #s(literal 1 binary64) x))) x))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 x y)) (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (*.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 x y)) (neg.f64 (/.f64 (log.f64 y) y))) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (neg (+ z y))) (neg.f64 (*.f64 (+.f64 (neg.f64 (log.f64 y)) (/.f64 (+.f64 z y) x)) x)))
#s(approx (- (+ (* (log y) x) (log t)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (log.f64 t) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (log.f64 t) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (neg y)) (neg.f64 (*.f64 (+.f64 (neg.f64 (log.f64 y)) (/.f64 y x)) x)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) x)) (/.f64 (log.f64 y) y)) x)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) x)) (/.f64 (log.f64 y) y)) x)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (log.f64 t) (*.f64 x y))) (/.f64 (log.f64 y) 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 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) 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 (-.f64 (*.f64 (log.f64 y) x) y) z))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (neg (+ z y)) (neg.f64 z))
#s(approx (neg (+ z y)) (-.f64 (neg.f64 y) z))
#s(approx (+ z y) z)
#s(approx (+ z y) (+.f64 z y))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (* (log y) x) (neg y)) (-.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (-.f64 (-.f64 (log.f64 t) z) (neg.f64 (*.f64 (log.f64 y) x))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (+.f64 (-.f64 (log.f64 t) z) (-.f64 (*.f64 (log.f64 y) x) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (-.f64 (-.f64 (log.f64 t) z) (neg.f64 (*.f64 (log.f64 y) x))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (+.f64 (-.f64 (log.f64 t) z) (-.f64 (*.f64 (log.f64 y) x) y)) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) y))
#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 (/ z y) (/.f64 z y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (+ (* (log y) x) (neg (+ z y))) (*.f64 (-.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) (/.f64 z y)) y))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (neg (+ z y)) (*.f64 (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64)) y))
#s(approx (+ z y) (*.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) y))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) y))
#s(approx (+ (* (log y) x) (log t)) (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (+ (* (log y) x) (neg y)) (*.f64 (fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) #s(literal -1 binary64)) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 (+.f64 z (*.f64 (neg.f64 (log.f64 y)) x)) y)) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 (+.f64 z (*.f64 (neg.f64 (log.f64 y)) x)) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y))
#s(approx (neg (* x (/ (neg (log y)) y))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
#s(approx (* x (/ (neg (log y)) y)) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
#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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z) y)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (neg (+ z y))) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x) z) y)) #s(literal 1 binary64))))
#s(approx (log y) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)))
#s(approx (neg (+ z y)) (*.f64 (neg.f64 y) (+.f64 (/.f64 z y) #s(literal 1 binary64))))
#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)) y) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) y)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)))
#s(approx (+ (* (log y) x) (neg y)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y))) #s(literal 1 binary64))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (neg.f64 y) (+.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (-.f64 (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x) z)) y)) #s(literal 1 binary64)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y)) #s(literal 1 binary64)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y)))
#s(approx (neg (* x (/ (neg (log y)) y))) (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y)))
#s(approx (* x (/ (neg (log y)) y)) (neg.f64 (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y))))
#s(approx (/ (neg (log y)) y) (/.f64 (neg.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64))) y))
#s(approx (neg (log y)) (neg.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) y))
#s(approx (+ (* (log y) x) (neg (+ z y))) (-.f64 (-.f64 (*.f64 (log.f64 y) x) z) y))
#s(approx (neg (+ z y)) (-.f64 (neg.f64 y) z))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (fma.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y (neg.f64 z)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (+.f64 (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64)) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)))
#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 (+ (* (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 (neg (+ z y)) (*.f64 (-.f64 (/.f64 (neg.f64 y) z) #s(literal 1 binary64)) z))
#s(approx (+ z y) (*.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z) #s(literal -1 binary64)) z))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 z y)) (/.f64 (neg.f64 (*.f64 (log.f64 y) x)) (*.f64 z y))) (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y))) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (neg (+ z y))) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) y) z)) #s(literal 1 binary64))))
#s(approx (neg (+ z y)) (*.f64 (neg.f64 z) (+.f64 (/.f64 y z) #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) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y) z)) #s(literal 1 binary64))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y))))
#s(approx t t)
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y) z))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (/ (log t) y) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y) z))
#s(approx (log t) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) 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)))) #s(literal 0 binary64)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (/ (log t) y) (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y))

eval75.0ms (1.8%)

Memory
9.7MiB live, 60.6MiB allocated; 14ms collecting garbage
Compiler

Compiled 3 445 to 1 320 computations (61.7% saved)

prune18.0ms (0.4%)

Memory
-5.5MiB live, 39.3MiB allocated; 6ms collecting garbage
Pruning

18 alts after pruning (16 fresh and 2 done)

PrunedKeptTotal
New28813301
Fresh033
Picked325
Done000
Total29118309
Accuracy
99.9%
Counts
309 → 18
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.0%
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
72.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
✓67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
▶72.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
40.8%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
▶77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
▶62.4%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
68.8%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (*.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 x y)) (neg.f64 (/.f64 (log.f64 y) y))) x)) #s(literal 1 binary64)) (/.f64 z y)) y))
▶78.1%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
28.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
23.2%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
67.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 z y)) (/.f64 (neg.f64 (*.f64 (log.f64 y) x)) (*.f64 z y))) (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y))) z)) y))
68.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y)))) y))
▶29.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
✓33.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
62.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z) #s(literal -1 binary64)) z)))
Compiler

Compiled 799 to 765 computations (4.3% saved)

series342.0ms (8.3%)

Memory
18.4MiB live, 538.3MiB allocated; 111ms collecting garbage
Counts
39 → 176
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
(*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64)))
(neg.f64 z)
z
(+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))
(neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(fma.f64 (log.f64 y) x (log.f64 t))
(log.f64 y)
y
x
(log.f64 t)
t
#s(literal 1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
(*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y)
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64))
#s(literal -1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))
(/.f64 (log.f64 t) y)
(/.f64 z y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y)))))
(neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))
(*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y)))
(*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))
(neg.f64 (log.f64 y))
(/.f64 #s(literal 1 binary64) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z)))) (* x (log y)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (/ (log t) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (log y)) z)) (/ y z))) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (+ (* -1 (/ (* x (log y)) z)) (/ y z)) (/ (log t) 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) z) (/ (* x (log y)) z)) (/ y z))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#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 #s(hole binary64 x))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* x (log y)) (* y (- (/ (log t) y) (+ 1 (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ z y)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) (+ 1 (/ z y)))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (log t) y)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (+ (/ (log t) y) (/ (* x (log y)) y))))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (* -1 (/ (* x (log y)) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (/ (* x (log y)) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* x (- (+ (/ 1 x) (/ y (* x z))) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* x (- (/ y (* x z)) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* x (- (+ (/ (log t) (* x z)) (/ (log y) z)) (/ y (* x z))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* x (+ (log y) (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (+ (/ 1 x) (/ z (* x y))))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* x (- (/ (log t) (* x y)) (* -1 (/ (log y) y))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (+ 1 (/ y z)) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ y z) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (- (/ (log t) z) (/ y z)) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) (+ 1 (/ z y))) x)) (/ (log y) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) 1) x)) (/ (log y) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log t) (* x y))) (/ (log y) y))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 y) (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (/ (log t) z) (/ (* 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 (+ (* -1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (log t) (+ z (* -1 (* x (log y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (log t) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y))))) 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) (* -1 y))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (log t) (* -1 (* x (log y)))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (* -1 (* x (log y)))) y)))
#s(approx (/ z y) #s(hole binary64 (/ z y)))
#s(approx (* (neg (log y)) (/ 1 y)) #s(hole binary64 (* -1 (/ (log y) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (log y))))
#s(approx (/ 1 y) #s(hole binary64 (/ 1 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* y (- (* -1 (/ (* z (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))) y)) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ y z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* y (- (+ (/ 1 y) (/ 1 z)) (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* y (+ (* -1 (/ (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)) y)) (/ 1 z)))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (/ y z))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z))) (/ 1 z)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 -1))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y))))))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ (* x (log (/ 1 y))) y)))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (- (log t) (* x (log (/ 1 y)))) y)))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) y))))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (/ (* x (log (/ 1 y))) y)))
#s(approx (* (neg (log y)) (/ 1 y)) #s(hole binary64 (/ (log (/ 1 y)) y)))
#s(approx (neg (log y)) #s(hole binary64 (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* y (+ 1 (/ (* z (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))) y))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* y (- (* -1 (/ (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))) y)) (/ 1 z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* y (- (+ (/ (log t) (* y z)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* y z))) (/ 1 z))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)) y)) (/ 1 z))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* y (- (+ 1 (* -1 (/ (log t) y))) (+ (* -1 (/ z y)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (+ (* -1 z) (* x (+ (log -1) (* -1 (log (/ -1 y))))))) y)) 1)))
#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 t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y))))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y))))
#s(approx (* (neg (log y)) (/ 1 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 (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (- y (+ (log t) (* x (log y)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 z) (* -1 (- y (+ (log t) (* x (log y))))))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- y (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- (+ y z) (+ (log t) (* x (log y)))) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (/ (- (+ (log t) (* x (log y))) y) z)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* -1 z) (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ z y)) (/ (log t) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* z (- (* -1 (/ (- y (+ (log t) (* x (log y)))) z)) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 1))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* z (- (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z) 1))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (/ z y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* z (- (/ (log t) (* y z)) (+ (* -1 (/ (* x (log y)) (* y z))) (+ (/ 1 y) (/ 1 z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) 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 (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (/ (- (+ (log t) (* x (log y))) y) z))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))) z)) (/ 1 y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx t #s(hole binary64 t))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (/ (log t) y) (* -1 (/ (* x (log y)) y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log 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 y) x) (log t)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#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) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (* -1 (/ (log (/ 1 t)) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log 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 y) x) (log t)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#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) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) y)))
Calls

12 calls:

TimeVariablePointExpression
84.0ms
z
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg z) z (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/ (- (+ (* (log y) x) (log t)) y) z) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (log y) y x (log t) t 1 (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) -1 (+ (- (- (* x (log y)) y) z) (log t)) (- (- (log t) y) z) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (/ z y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) (neg (* x (* (neg (log y)) (/ 1 y)))) (* x (* (neg (log y)) (/ 1 y))) (* (neg (log y)) (/ 1 y)) (neg (log y)) (/ 1 y))
44.0ms
y
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg z) z (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/ (- (+ (* (log y) x) (log t)) y) z) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (log y) y x (log t) t 1 (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) -1 (+ (- (- (* x (log y)) y) z) (log t)) (- (- (log t) y) z) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (/ z y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) (neg (* x (* (neg (log y)) (/ 1 y)))) (* x (* (neg (log y)) (/ 1 y))) (* (neg (log y)) (/ 1 y)) (neg (log y)) (/ 1 y))
36.0ms
x
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg z) z (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/ (- (+ (* (log y) x) (log t)) y) z) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (log y) y x (log t) t 1 (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) -1 (+ (- (- (* x (log y)) y) z) (log t)) (- (- (log t) y) z) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (/ z y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) (neg (* x (* (neg (log y)) (/ 1 y)))) (* x (* (neg (log y)) (/ 1 y))) (* (neg (log y)) (/ 1 y)) (neg (log y)) (/ 1 y))
27.0ms
t
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg z) z (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/ (- (+ (* (log y) x) (log t)) y) z) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (log y) y x (log t) t 1 (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) -1 (+ (- (- (* x (log y)) y) z) (log t)) (- (- (log t) y) z) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (/ z y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) (neg (* x (* (neg (log y)) (/ 1 y)))) (* x (* (neg (log y)) (/ 1 y))) (* (neg (log y)) (/ 1 y)) (neg (log y)) (/ 1 y))
24.0ms
y
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg z) z (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/ (- (+ (* (log y) x) (log t)) y) z) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (log y) y x (log t) t 1 (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) -1 (+ (- (- (* x (log y)) y) z) (log t)) (- (- (log t) y) z) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/ (log t) y) (/ z y) (+ (- (- (* x (log y)) y) z) (log t)) (* (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) y) (- (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (/ z y)) (- (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) 1) (+ (/ (log t) y) (neg (* x (* (neg (log y)) (/ 1 y))))) (neg (* x (* (neg (log y)) (/ 1 y)))) (* x (* (neg (log y)) (/ 1 y))) (* (neg (log y)) (/ 1 y)) (neg (log y)) (/ 1 y))

rewrite160.0ms (3.9%)

Memory
-21.4MiB live, 213.7MiB allocated; 29ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
06265328
06734621
044524589
1122864589
Stop Event
1×saturated
1×iter-limit
1×node-limit
1×iter-limit
Counts
215 → 370
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
(*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64)))
(neg.f64 z)
z
(+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))
(neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(fma.f64 (log.f64 y) x (log.f64 t))
(log.f64 y)
y
x
(log.f64 t)
t
#s(literal 1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
(*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y)
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64))
#s(literal -1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))
(/.f64 (log.f64 t) y)
(/.f64 z y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y)
(-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y)))))
(neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))
(*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y)))
(*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))
(neg.f64 (log.f64 y))
(/.f64 #s(literal 1 binary64) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z)))) (* x (log y)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (/ (log t) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (log y)) z)) (/ y z))) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (+ (* -1 (/ (* x (log y)) z)) (/ y z)) (/ (log t) 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) z) (/ (* x (log y)) z)) (/ y z))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#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 #s(hole binary64 x))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (/ z y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* x (log y)) (* y (- (/ (log t) y) (+ 1 (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ z y)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) (+ 1 (/ z y)))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) 1)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (/ (log t) y) (/ (* x (log y)) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (log t) y)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (+ (/ (log t) y) (/ (* x (log y)) y))))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (/ (* x (log y)) y)))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (* -1 (/ (* x (log y)) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (/ (* x (log y)) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* x (- (+ (/ 1 x) (/ y (* x z))) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* x (- (/ y (* x z)) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* x (- (+ (/ (log t) (* x z)) (/ (log y) z)) (/ y (* x z))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* x (+ (log y) (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (+ (/ 1 x) (/ z (* x y))))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* x (- (/ (log t) (* x y)) (+ (* -1 (/ (log y) y)) (/ 1 x))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* x (- (/ (log t) (* x y)) (* -1 (/ (log y) y))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (+ 1 (/ y z)) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ y z) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (- (/ (log t) z) (/ y z)) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* y (- (/ (log t) y) (+ 1 (/ z y)))) x)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) (+ 1 (/ z y))) x)) (/ (log y) y))))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ (log t) y) 1) x)) (/ (log y) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log t) (* x y))) (/ (log y) y))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 y) (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (/ (log t) z) (/ (* 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 (+ (* -1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (log t) (+ z (* -1 (* x (log y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (log t) (+ z (* -1 (* x (log y))))) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (+ z (* -1 (* x (log y))))) 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) (* -1 y))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (log t) (* -1 (* x (log y)))) y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (/ (- (+ (log t) (* -1 y)) (* -1 (* x (log y)))) y)))
#s(approx (/ z y) #s(hole binary64 (/ z y)))
#s(approx (* (neg (log y)) (/ 1 y)) #s(hole binary64 (* -1 (/ (log y) y))))
#s(approx (neg (log y)) #s(hole binary64 (* -1 (log y))))
#s(approx (/ 1 y) #s(hole binary64 (/ 1 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* y (- (* -1 (/ (* z (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))) y)) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ y z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* y (- (+ (/ 1 y) (/ 1 z)) (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* y (+ (* -1 (/ (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)) y)) (/ 1 z)))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (/ y z))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z))) (/ 1 z)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 -1))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (/ z y) (/ (* x (log (/ 1 y))) y))))))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (/ (log t) y) (+ 1 (/ (* x (log (/ 1 y))) y)))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (/ (- (log t) (* x (log (/ 1 y)))) y)))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) y))))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (/ (* x (log (/ 1 y))) y)))
#s(approx (* (neg (log y)) (/ 1 y)) #s(hole binary64 (/ (log (/ 1 y)) y)))
#s(approx (neg (log y)) #s(hole binary64 (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* y (+ 1 (/ (* z (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))) y))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* y (- (* -1 (/ (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))) y)) (/ 1 z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* y (- (+ (/ (log t) (* y z)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* y z))) (/ 1 z))))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)) y)) (/ 1 z))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* y (- (+ 1 (* -1 (/ (log t) y))) (+ (* -1 (/ z y)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (+ (* -1 z) (* x (+ (log -1) (* -1 (log (/ -1 y))))))) y)) 1)))
#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 t) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)) 1)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (* -1 (/ (- (* -1 (log t)) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y))))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y)))
#s(approx (* x (* (neg (log y)) (/ 1 y))) #s(hole binary64 (* -1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) y))))
#s(approx (* (neg (log y)) (/ 1 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 (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (- y (+ (log t) (* x (log y)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 z) (* -1 (- y (+ (log t) (* x (log y))))))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- y (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- (+ y z) (+ (log t) (* x (log y)))) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) #s(hole binary64 (/ (- (+ (log t) (* x (log y))) y) z)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (+ (* -1 z) (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ z y)) (/ (log t) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (- (+ (log t) (* -1 z)) y)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* z (- (* -1 (/ (- y (+ (log t) (* x (log y)))) z)) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 1))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* z (- (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z) 1))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (/ z y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* z (- (/ (log t) (* y z)) (+ (* -1 (/ (* x (log y)) (* y z))) (+ (/ 1 y) (/ 1 z)))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* z (- (/ (log t) 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 (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (/ (- (+ (log t) (* x (log y))) y) z))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (* y (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y))))) z)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (- (/ (log t) y) (+ 1 (* -1 (/ (* x (log y)) y)))) z)) (/ 1 y))))))
#s(approx (- (- (log t) y) z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ (- (log t) y) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx t #s(hole binary64 t))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (/ (log t) y) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (/ (log t) y) (* -1 (/ (* x (log y)) y)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log 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 y) x) (log t)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#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) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (* -1 (/ (log (/ 1 t)) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (* -1 (/ (log (/ 1 t)) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log 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 y) x) (log t)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y)))))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (+ (* -1 (/ (* x (log y)) y)) (/ z y))))))
#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) y) (neg (* x (/ (neg (log y)) y)))) 1) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (+ 1 (* -1 (/ (* x (log y)) y))))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) #s(hole binary64 (- (+ (* -1 (/ (log (/ -1 t)) y)) (/ (log -1) y)) (* -1 (/ (* x (log y)) y)))))
#s(approx (/ (log t) y) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) y)))
Outputs
#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)))
(*.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) z) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) (neg.f64 z))
(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) z))
(*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
(neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) z))
(fma.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) (neg.f64 z) (*.f64 #s(literal 1 binary64) (neg.f64 z)))
(fma.f64 (neg.f64 z) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) (*.f64 (neg.f64 z) #s(literal 1 binary64)))
(+.f64 (*.f64 (neg.f64 z) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) (*.f64 (neg.f64 z) #s(literal 1 binary64)))
(+.f64 (*.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) (neg.f64 z)) (*.f64 #s(literal 1 binary64) (neg.f64 z)))
(*.f64 #s(literal -1 binary64) z)
(*.f64 z #s(literal -1 binary64))
(neg.f64 z)
z
(neg.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64)))
(fma.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64) #s(literal 1 binary64))
(fma.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64))
(-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) (/.f64 (*.f64 (log.f64 y) x) z))
(-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(-.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) #s(literal -1 binary64))
(-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
(-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z)) (-.f64 (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z)))
(+.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(+.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
(*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64))
(*.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z))
(*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)) z)
(/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (neg.f64 z))
(/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)
(neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(fma.f64 y (/.f64 #s(literal 1 binary64) z) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(-.f64 (/.f64 (-.f64 y (log.f64 t)) z) (/.f64 (*.f64 (log.f64 y) x) z))
(-.f64 (/.f64 y z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(+.f64 (/.f64 y z) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(*.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (/.f64 #s(literal 1 binary64) z))
(*.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
(/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)
(/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (neg.f64 z))
(neg.f64 (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
(fma.f64 (/.f64 y z) #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(fma.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (/.f64 #s(literal 1 binary64) z) (/.f64 (neg.f64 y) z))
(fma.f64 #s(literal -1 binary64) (/.f64 y z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) z) (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) (/.f64 y z)))
(-.f64 (/.f64 (neg.f64 y) z) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (/.f64 y z))
(+.f64 (+.f64 (/.f64 (neg.f64 y) z) (/.f64 (log.f64 t) z)) (/.f64 (*.f64 (log.f64 y) x) z))
(+.f64 (/.f64 (neg.f64 y) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(+.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (/.f64 (neg.f64 y) z))
(+.f64 (/.f64 (log.f64 t) z) (-.f64 (/.f64 (*.f64 (log.f64 y) x) z) (/.f64 y z)))
(*.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))))
(neg.f64 (-.f64 (neg.f64 (*.f64 (log.f64 y) x)) (-.f64 (log.f64 t) y)))
(neg.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))))
(fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y))
(fma.f64 x (log.f64 y) (-.f64 (log.f64 t) y))
(-.f64 (-.f64 (log.f64 t) y) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(-.f64 (log.f64 t) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) y)))
(+.f64 (-.f64 (log.f64 t) y) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 y) x)))
(+.f64 (-.f64 (log.f64 t) y) (neg.f64 (neg.f64 (*.f64 (log.f64 y) x))))
(+.f64 (-.f64 (log.f64 t) y) (*.f64 (log.f64 y) x))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (neg.f64 y))
(+.f64 (log.f64 t) (-.f64 (*.f64 (log.f64 y) x) y))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (log.f64 t))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (log.f64 t) y))
(neg.f64 (-.f64 (neg.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 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y)))
(-.f64 (log.f64 t) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (log.f64 t)))
(+.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 y) x)))
(+.f64 (log.f64 t) (neg.f64 (neg.f64 (*.f64 (log.f64 y) x))))
(+.f64 (log.f64 t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(log.f64 (fabs.f64 y))
(log.f64 y)
y
x
(log.f64 (fabs.f64 t))
(log.f64 t)
t
#s(literal 1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
(*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y)
(*.f64 y #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64))
#s(literal -1 binary64)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
(neg.f64 (-.f64 z (-.f64 (log.f64 t) y)))
(neg.f64 (-.f64 (+.f64 z y) (log.f64 t)))
(-.f64 (-.f64 (log.f64 t) y) z)
(-.f64 (log.f64 t) (+.f64 z y))
(+.f64 (-.f64 (log.f64 t) y) (neg.f64 z))
(+.f64 (log.f64 t) (-.f64 (neg.f64 y) z))
(+.f64 (log.f64 t) (neg.f64 (+.f64 z y)))
(neg.f64 (-.f64 y (log.f64 t)))
(fma.f64 #s(literal -1 binary64) y (log.f64 t))
(fma.f64 y #s(literal -1 binary64) (log.f64 t))
(-.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) y))
(-.f64 (log.f64 t) (neg.f64 (neg.f64 y)))
(-.f64 (log.f64 t) y)
(+.f64 (neg.f64 y) (log.f64 t))
(+.f64 (log.f64 t) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y)
(*.f64 y (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)))
(neg.f64 (-.f64 (/.f64 z y) (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64))))
(-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) (+.f64 (/.f64 z y) #s(literal 1 binary64)))
(+.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 (neg.f64 z) y))
(neg.f64 (-.f64 #s(literal 1 binary64) #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))))
(-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64))
(+.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal -1 binary64))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))
(*.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 (log.f64 t)) (neg.f64 y))
(/.f64 (log.f64 t) y)
(*.f64 z (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 z) (neg.f64 y))
(/.f64 z y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y))
(*.f64 (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y)
(*.f64 y (-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)))
(neg.f64 (-.f64 (/.f64 z y) (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64))))
(neg.f64 (-.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)))
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y) (neg.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64))))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(-.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y))
(-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) (+.f64 (/.f64 z y) #s(literal 1 binary64)))
(+.f64 (-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 1 binary64)) (/.f64 (-.f64 (log.f64 t) z) y))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
(+.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 (neg.f64 z) y))
(+.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) (neg.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64))))
(neg.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)))
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y) #s(literal -1 binary64))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y) (-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 1 binary64)))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
(+.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal -1 binary64))
(+.f64 (/.f64 (log.f64 t) y) (-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) #s(literal 1 binary64)))
(*.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) (/.f64 #s(literal 1 binary64) y))
(/.f64 (neg.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x))) (neg.f64 y))
(/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y)
(fma.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)) (/.f64 (log.f64 t) y))
(fma.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64) (/.f64 (log.f64 t) y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) (/.f64 (log.f64 t) y))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) y) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
(fma.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 (log.f64 t) y))
(-.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (neg.f64 (/.f64 (log.f64 t) y)))
(-.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)))))
(-.f64 (/.f64 (log.f64 t) y) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(+.f64 (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 (log.f64 t) y))
(+.f64 (/.f64 (log.f64 t) y) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
(*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y)))
(*.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(*.f64 x (neg.f64 (neg.f64 (/.f64 (log.f64 y) y))))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) y)
(neg.f64 (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
(*.f64 (*.f64 (neg.f64 (log.f64 y)) x) (/.f64 #s(literal 1 binary64) y))
(*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x)
(*.f64 x (neg.f64 (/.f64 (log.f64 y) y)))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (neg.f64 y))
(/.f64 (*.f64 (neg.f64 (log.f64 y)) x) y)
(*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))
(*.f64 (/.f64 (log.f64 y) y) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) y) (neg.f64 (log.f64 y)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) y))
(/.f64 (*.f64 (neg.f64 (log.f64 y)) #s(literal 1 binary64)) y)
(/.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))
(*.f64 (log.f64 y) #s(literal -1 binary64))
(neg.f64 (log.f64 y))
(log.f64 (fabs.f64 (/.f64 #s(literal 1 binary64) y)))
(log.f64 (/.f64 #s(literal 1 binary64) y))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(pow.f64 y #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 y))
(/.f64 #s(literal 1 binary64) y)
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) (*.f64 (log.f64 y) x)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (+.f64 #s(literal 1 binary64) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (-.f64 y (log.f64 t)) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (log.f64 t)) z))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (-.f64 y (log.f64 t)) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (log.f64 t) y) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (log.f64 t) y))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#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 x x)
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (fma.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y (*.f64 (log.f64 y) x)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 1 binary64)) (/.f64 z y)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) #s(literal 1 binary64)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) (/.f64 (*.f64 (log.f64 y) x) y))
#s(approx (* x (* (neg (log y)) (/ 1 y))) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (+.f64 (/.f64 (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z))) x) (log.f64 y)) x))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 y (*.f64 z x)) (/.f64 #s(literal 1 binary64) x)) (/.f64 (log.f64 t) (*.f64 z x))) (/.f64 (log.f64 y) z)) x))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (*.f64 (-.f64 (-.f64 (/.f64 y (*.f64 z x)) (/.f64 (log.f64 t) (*.f64 z x))) (/.f64 (log.f64 y) z)) x))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (*.f64 (log.f64 y) x) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (*.f64 (+.f64 (/.f64 (log.f64 t) (*.f64 z x)) (-.f64 (/.f64 (log.f64 y) z) (/.f64 y (*.f64 z x)))) x))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (log.f64 t) y) x)) x))
#s(approx (+ (* (log y) x) (log t)) (*.f64 (+.f64 (/.f64 (log.f64 t) x) (log.f64 y)) x))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) x) (log.f64 y)) x))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 y x)) (neg.f64 (/.f64 (log.f64 y) y))) (+.f64 (/.f64 z (*.f64 y x)) (/.f64 #s(literal 1 binary64) x))) x))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 y x)) (neg.f64 (/.f64 (log.f64 y) y))) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (*.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 y x)) (neg.f64 (/.f64 (log.f64 y) y))) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg.f64 (*.f64 (fma.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) x)) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (-.f64 y (log.f64 t)) z) x)) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (neg.f64 (*.f64 (+.f64 (/.f64 (/.f64 (-.f64 y (log.f64 t)) z) x) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (- (+ (* (log y) x) (log t)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (log.f64 t) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (log.f64 t) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 z y)) x)) (/.f64 (log.f64 y) y)) x)))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) x)) (/.f64 (log.f64 y) y)) x)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (log.f64 t) (*.f64 y x))) (/.f64 (log.f64 y) 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 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (-.f64 (-.f64 (log.f64 t) z) (neg.f64 (*.f64 (log.f64 y) x))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (+.f64 (-.f64 (log.f64 t) z) (-.f64 (*.f64 (log.f64 y) x) y)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (-.f64 (-.f64 (log.f64 t) z) (neg.f64 (*.f64 (log.f64 y) x))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (+.f64 (-.f64 (log.f64 t) z) (-.f64 (*.f64 (log.f64 y) x) y)) y))
#s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z))
#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) y) (neg (* x (/ (neg (log y)) y)))) 1) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) y))
#s(approx (/ z y) (/.f64 z y))
#s(approx (* (neg (log y)) (/ 1 y)) (neg.f64 (/.f64 (log.f64 y) y)))
#s(approx (neg (log y)) (neg.f64 (log.f64 y)))
#s(approx (/ 1 y) (/.f64 #s(literal 1 binary64) 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 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (-.f64 #s(literal 1 binary64) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)))) (/.f64 (log.f64 t) z)) z) y)) #s(literal 1 binary64)) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y)) (/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (*.f64 z y))) (/.f64 (log.f64 t) (*.f64 z y))) y))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (fma.f64 y (neg.f64 (/.f64 (+.f64 (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z))) (/.f64 (log.f64 t) z)) y)) (/.f64 y z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (neg.f64 y) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (*.f64 (-.f64 (+.f64 (/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (*.f64 z y)) (/.f64 (log.f64 t) (*.f64 z y))) (/.f64 #s(literal 1 binary64) z)) y))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (-.f64 (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y) #s(literal 1 binary64)) y))
#s(approx (+ (* (log y) x) (log t)) (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 (+.f64 z (*.f64 (neg.f64 (log.f64 y)) x)) y)) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (/.f64 (+.f64 z (*.f64 (neg.f64 (log.f64 y)) x)) y)))
#s(approx (- (log t) y) (*.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (/.f64 (log.f64 t) y) (fma.f64 (neg.f64 (/.f64 (log.f64 y) y)) x #s(literal 1 binary64))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (-.f64 (log.f64 t) (*.f64 (neg.f64 (log.f64 y)) x)) y))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) (*.f64 (neg.f64 x) (neg.f64 (/.f64 (log.f64 y) y))))
#s(approx (* x (* (neg (log y)) (/ 1 y))) (*.f64 (neg.f64 (/.f64 (log.f64 y) y)) x))
#s(approx (* (neg (log y)) (/ 1 y)) (neg.f64 (/.f64 (log.f64 y) y)))
#s(approx (neg (log y)) (neg.f64 (log.f64 y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z) y)) #s(literal 1 binary64))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 y) (fma.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z)) y) #s(literal 1 binary64))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (neg.f64 y) (-.f64 (neg.f64 (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z)) y)) (/.f64 #s(literal 1 binary64) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (*.f64 (neg.f64 y) (-.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) (*.f64 z y)) (/.f64 #s(literal 1 binary64) z))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (neg.f64 (fma.f64 y (neg.f64 (/.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z) y)) (/.f64 y z))))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) y)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)))
#s(approx (log y) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (neg.f64 y) (+.f64 (+.f64 (/.f64 z y) #s(literal 1 binary64)) (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (neg.f64 z))) y)) #s(literal 1 binary64)))
#s(approx (- (- (log t) y) z) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (log.f64 t) z) y)) #s(literal 1 binary64))))
#s(approx (- (log t) y) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (log.f64 t) y)) #s(literal 1 binary64))))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y)) #s(literal 1 binary64)))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (neg.f64 (/.f64 (-.f64 (neg.f64 (log.f64 t)) (*.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x)) y)))
#s(approx (neg (* x (* (neg (log y)) (/ 1 y)))) (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y)))
#s(approx (* x (* (neg (log y)) (/ 1 y))) (neg.f64 (*.f64 x (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) y))))
#s(approx (* (neg (log y)) (/ 1 y)) (/.f64 (neg.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64))) y))
#s(approx (neg (log y)) (neg.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (-.f64 (log.f64 t) z) (*.f64 (log.f64 y) x)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (neg z) (neg.f64 z))
#s(approx z z)
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 (-.f64 (+.f64 z y) (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (fma.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y (neg.f64 z)))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (+.f64 (-.f64 (/.f64 (neg.f64 z) y) #s(literal 1 binary64)) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)))
#s(approx (- (- (log t) y) z) (-.f64 (-.f64 (log.f64 t) z) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64)) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64)) z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(literal 1 binary64))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z) #s(literal -1 binary64)) z))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 z y)) (/.f64 (neg.f64 (*.f64 (log.f64 y) x)) (*.f64 z y))) (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y))) z))
#s(approx (- (- (log t) y) z) (*.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) 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 (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) y) z)) #s(literal 1 binary64))))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y))))
#s(approx (- (- (log t) y) z) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) (neg.f64 z)))
#s(approx t t)
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y) z))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))) y))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (neg.f64 (neg.f64 (log.f64 t)))))
#s(approx (log t) (neg.f64 (neg.f64 (log.f64 t))))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (- (- (log t) y) z) (-.f64 (-.f64 (neg.f64 (neg.f64 (log.f64 t))) y) z))
#s(approx (- (log t) y) (-.f64 (neg.f64 (neg.f64 (log.f64 t))) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (/ (log t) y) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (-.f64 (/.f64 y z) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z)))
#s(approx (/ (- (+ (* (log y) x) (log t)) y) z) (/.f64 (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y) z))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) 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)))) #s(literal 0 binary64)))
#s(approx (log t) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)))
#s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))) y))
#s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y)) (/.f64 z y))))
#s(approx (- (- (log t) y) z) (+.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)))
#s(approx (- (log t) y) (-.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y))
#s(approx (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (-.f64 (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))))
#s(approx (/ (log t) y) (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y))

eval55.0ms (1.3%)

Memory
5.1MiB live, 96.7MiB allocated; 7ms collecting garbage
Compiler

Compiled 4 800 to 1 904 computations (60.3% saved)

prune16.0ms (0.4%)

Memory
34.1MiB live, 34.1MiB allocated; 0ms collecting garbage
Pruning

21 alts after pruning (16 fresh and 5 done)

PrunedKeptTotal
New3448352
Fresh3811
Picked235
Done022
Total34921370
Accuracy
100.0%
Counts
370 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.0%
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
▶67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
72.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
✓67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
✓72.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (log.f64 t) y) z))
▶40.8%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
✓77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
✓62.4%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
78.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (fma.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64))))
77.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) (/.f64 (*.f64 (log.f64 y) x) z))))
▶77.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
17.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
60.7%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
28.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
23.2%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
68.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y)))) y))
✓33.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
▶29.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
45.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
▶88.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))))
Compiler

Compiled 791 to 759 computations (4% saved)

series244.0ms (6%)

Memory
-12.2MiB live, 475.8MiB allocated; 54ms collecting garbage
Counts
33 → 131
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y)))
(fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))
(neg.f64 z)
z
(-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(literal 1 binary64)
(/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)
(fma.f64 (log.f64 y) x (log.f64 t))
(log.f64 y)
y
x
(log.f64 t)
t
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y)
#s(approx (+ (* (log y) x) (log t)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y))
(-.f64 (log.f64 t) y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
(*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64)))
(+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))))
(-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))
(/.f64 y z)
(fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))
(/.f64 (log.f64 y) z)
(/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)
(neg.f64 (neg.f64 (log.f64 t)))
(neg.f64 (log.f64 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z)))) (* x (log y)))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (/ (log t) z)))) y)))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (+ (* -1 (* z (- 1 (/ (log t) z)))) (* x (log y))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (/ (log t) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (log y)) z))) (/ (log t) z))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (log t) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (+ (/ (log t) z) (/ (* x (log 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 #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (/ (log t) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (log y)) z)) (/ y z))) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (+ (* -1 (/ (* x (log y)) z)) (/ y z)) (/ (log t) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* x (- (+ (log y) (* -1 (/ (* z (- 1 (/ (log t) z))) x))) (/ y x)))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (/ (* x (log y)) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* x (- (/ 1 x) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (* x (+ (/ (log t) (* x z)) (/ (log y) z)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* x (- (+ (/ 1 x) (/ y (* x z))) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* x (- (/ y (* x z)) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (* -1 (* z (- 1 (/ (log t) z)))) y) x)))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- 1 (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log t) (* x z))) (* -1 (/ (log y) z)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (+ 1 (/ y z)) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ y z) (/ (log t) z)) x)) (* -1 (/ (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 y) (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* 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)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (- (log t) y) #s(hole binary64 (+ (log t) (* -1 y))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (/ y z) #s(hole binary64 (/ y z)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* y (- (* -1 (/ (* z (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))) y)) 1))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* -1 (* x (log (/ 1 y))))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* y (- (+ (/ 1 y) (/ 1 z)) (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* y (+ (* -1 (/ (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)) y)) (/ 1 z)))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* y (+ 1 (/ (* z (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))) y))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (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)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (log t) y)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* y (- (* -1 (/ (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))) y)) (/ 1 z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* y (- (+ (/ (log t) (* y z)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* y z))) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (/ (log t) z) (/ (* 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 (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (- y (+ (log t) (* x (log y)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 z) (* -1 (- y (+ (log t) (* x (log y))))))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (/ (+ (log t) (* x (log y))) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (/ (- z (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- y (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- (+ y z) (+ (log t) (* x (log y)))) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* z (- (* -1 (/ (- y (+ (log t) (* x (log y)))) z)) 1))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 1))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (+ 1 (* -1 (/ (+ (log t) (* x (log 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 (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* -1 (* z (+ 1 (+ (* -1 (/ (+ (log t) (* x (log y))) z)) (/ y z)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (/ (- (+ (log t) (* x (log y))) y) z))))
#s(approx (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) #s(hole binary64 (* -1 (/ (- (* -1 y) (+ (* -1 (log t)) (* -1 (* x (log y))))) z))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (log t)) (* -1 (* x (log y)))) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))) y)))
#s(approx t #s(hole binary64 t))
#s(approx (neg (log t)) #s(hole binary64 (* -1 (log t))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z))))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (* -1 (log (/ 1 t))) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (- (log t) y) #s(hole binary64 (- (* -1 (log (/ 1 t))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z))))
#s(approx (/ (neg (neg (log t))) z) #s(hole binary64 (* -1 (/ (log (/ 1 t)) z))))
#s(approx (neg (log t)) #s(hole binary64 (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z)))))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (- (log t) y) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z)))))
#s(approx (/ (neg (neg (log t))) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) z)))
#s(approx (neg (log t)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 t)))))))
Calls

12 calls:

TimeVariablePointExpression
65.0ms
x
@0
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg z) z (- 1 (/ (+ (* (log y) x) (log t)) z)) 1 (/ (+ (* (log y) x) (log t)) z) (+ (* (log y) x) (log t)) (log y) y x (log t) t (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (+ (* (log y) x) (- (log t) y)) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) (/ (log y) z) (/ (neg (neg (log t))) z) (neg (neg (log t))) (neg (log t)))
23.0ms
z
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg z) z (- 1 (/ (+ (* (log y) x) (log t)) z)) 1 (/ (+ (* (log y) x) (log t)) z) (+ (* (log y) x) (log t)) (log y) y x (log t) t (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (+ (* (log y) x) (- (log t) y)) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) (/ (log y) z) (/ (neg (neg (log t))) z) (neg (neg (log t))) (neg (log t)))
22.0ms
z
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg z) z (- 1 (/ (+ (* (log y) x) (log t)) z)) 1 (/ (+ (* (log y) x) (log t)) z) (+ (* (log y) x) (log t)) (log y) y x (log t) t (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (+ (* (log y) x) (- (log t) y)) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) (/ (log y) z) (/ (neg (neg (log t))) z) (neg (neg (log t))) (neg (log t)))
20.0ms
y
@-inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg z) z (- 1 (/ (+ (* (log y) x) (log t)) z)) 1 (/ (+ (* (log y) x) (log t)) z) (+ (* (log y) x) (log t)) (log y) y x (log t) t (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (+ (* (log y) x) (- (log t) y)) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) (/ (log y) z) (/ (neg (neg (log t))) z) (neg (neg (log t))) (neg (log t)))
18.0ms
y
@inf
((+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg z) z (- 1 (/ (+ (* (log y) x) (log t)) z)) 1 (/ (+ (* (log y) x) (log t)) z) (+ (* (log y) x) (log t)) (log y) y x (log t) t (neg y) (+ (- (- (* x (log y)) y) z) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (- (+ (* (log y) x) (log t)) y) (+ (* (log y) x) (log t)) (+ (- (- (* x (log y)) y) z) (log t)) (+ (* (log y) x) (- (log t) y)) (- (log t) y) (+ (- (- (* x (log y)) y) z) (log t)) (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) (/ (log y) z) (/ (neg (neg (log t))) z) (neg (neg (log t))) (neg (log t)))

rewrite173.0ms (4.2%)

Memory
8.1MiB live, 183.3MiB allocated; 26ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
04773687
05173183
033383164
187483164
Stop Event
1×saturated
1×iter-limit
1×node-limit
1×iter-limit
Counts
164 → 297
Calls
Call 1
Inputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y)))
(fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))
(neg.f64 z)
z
(-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(literal 1 binary64)
(/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)
(fma.f64 (log.f64 y) x (log.f64 t))
(log.f64 y)
y
x
(log.f64 t)
t
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y)
#s(approx (+ (* (log y) x) (log t)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y))
(-.f64 (log.f64 t) y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
(*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64)))
(+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))))
(-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))
(/.f64 y z)
(fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z))
(/.f64 (log.f64 y) z)
(/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)
(neg.f64 (neg.f64 (log.f64 t)))
(neg.f64 (log.f64 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 (* z (- (+ 1 (/ y z)) (/ (log t) z)))) (* x (log y)))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (/ (log t) z)))) y)))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (+ (* -1 (* z (- 1 (/ (log t) z)))) (* x (log y))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (/ (log t) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (log y)) z))) (/ (log t) z))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (log t) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (+ (/ (log t) z) (/ (* x (log 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 #s(hole binary64 x))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (log t) y)))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log t) (* x (log y))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (/ (log t) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (log y)) z)) (/ y z))) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (/ (log t) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (+ (* -1 (/ (* x (log y)) z)) (/ y z)) (/ (log t) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* x (+ (log y) (* -1 (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* x (- (+ (log y) (* -1 (/ (* z (- 1 (/ (log t) z))) x))) (/ y x)))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (/ (* x (log y)) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* x (- (/ 1 x) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (* x (+ (/ (log t) (* x z)) (/ (log y) z)))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* x (+ (log y) (/ (log t) x)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* x (- (+ (log y) (/ (log t) x)) (/ y x)))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* x (- (+ (/ 1 x) (/ y (* x z))) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* x (- (/ y (* x z)) (+ (/ (log t) (* x z)) (/ (log y) z))))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (/ (* z (- (+ 1 (/ y z)) (/ (log t) z))) x))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (* -1 (* z (- 1 (/ (log t) z)))) y) x)))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- 1 (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log t) (* x z))) (* -1 (/ (log y) z)))))))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (log t) x)))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (- (log t) y) x)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (+ 1 (/ y z)) (/ (log t) z)) x)) (* -1 (/ (log y) z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (- (/ y z) (/ (log t) z)) x)) (* -1 (/ (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 y) (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* 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)) y) #s(hole binary64 (+ (log t) (+ (* -1 y) (* x (log y))))))
#s(approx (- (log t) y) #s(hole binary64 (+ (log t) (* -1 y))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (/ (log t) z) (/ (* x (log y)) z)))))
#s(approx (/ y z) #s(hole binary64 (/ y z)))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* y (- (* -1 (/ (* z (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))) y)) 1))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* -1 (* x (log (/ 1 y))))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* -1 (* x (log (/ 1 y)))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (* y (- (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (log t) y)) 1))))
#s(approx (- (log t) y) #s(hole binary64 (* y (- (/ (log t) y) 1))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* y (- (+ (/ 1 y) (/ 1 z)) (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (/ (log t) (* y z)))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* y (+ (* -1 (/ (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z)) y)) (/ 1 z)))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (* x (log (/ 1 y))) z)) (/ (log t) z))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* y (+ 1 (/ (* z (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))) y))))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log t) (* x (+ (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)) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (+ (log t) (* x (+ (log -1) (* -1 (log (/ -1 y)))))) y)))))))
#s(approx (- (log t) y) #s(hole binary64 (* -1 (* y (+ 1 (* -1 (/ (log t) y)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (* -1 (* y (- (* -1 (/ (- 1 (+ (/ (log t) z) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))) y)) (/ 1 z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (* y (- (+ (/ (log t) (* y z)) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* y z))) (/ 1 z))))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (/ (log t) z) (/ (* 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 (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (log t) (+ (* -1 z) (* x (log y)))) y)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (- y (+ (log t) (* x (log y)))))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (+ (* -1 z) (* -1 (- y (+ (log t) (* x (log y))))))))
#s(approx (neg z) #s(hole binary64 (* -1 z)))
#s(approx z #s(hole binary64 z))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (* -1 (/ (+ (log t) (* x (log y))) z))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (/ (- z (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- y (+ (log t) (* x (log y)))) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (/ (- (+ y z) (+ (log t) (* x (log y)))) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* z (- (* -1 (/ (- y (+ (log t) (* x (log y)))) z)) 1))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 1))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (+ 1 (* -1 (/ (+ (log t) (* x (log 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 (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (* -1 (* z (+ 1 (+ (* -1 (/ (+ (log t) (* x (log y))) z)) (/ y z)))))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (log t) (* x (log y))) y) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (* -1 (/ (- (+ (log t) (* x (log y))) y) z))))
#s(approx (- (/ y z) (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z))) #s(hole binary64 (* -1 (/ (- (* -1 y) (+ (* -1 (log t)) (* -1 (* x (log y))))) z))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (log t)) (* -1 (* x (log y)))) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (/ (log t) z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (/ (log t) z) (/ (* x (log y)) z))))) y)))
#s(approx t #s(hole binary64 t))
#s(approx (neg (log t)) #s(hole binary64 (* -1 (log t))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) (+ y z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z))))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (* -1 (log (/ 1 t))) (* x (log y))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (* -1 (log (/ 1 t))) (* x (log y)))))
#s(approx (log t) #s(hole binary64 (* -1 (log (/ 1 t)))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (* -1 (log (/ 1 t))) (* x (log y))) y)))
#s(approx (- (log t) y) #s(hole binary64 (- (* -1 (log (/ 1 t))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z)))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 t)) z)) (/ (* x (log y)) z))))
#s(approx (/ (neg (neg (log t))) z) #s(hole binary64 (* -1 (/ (log (/ 1 t)) z))))
#s(approx (neg (log t)) #s(hole binary64 (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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) #s(hole binary64 (* -1 (* z (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) #s(hole binary64 (- (* -1 (* z (- 1 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z)))))) y)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(hole binary64 (- 1 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (/ (+ (* (log y) x) (log t)) z) #s(hole binary64 (/ (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) z)))
#s(approx (+ (* (log y) x) (log t)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y))))))
#s(approx (log t) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 t))))))
#s(approx (- (+ (* (log y) x) (log t)) y) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 t))) (* x (log y)))) y)))
#s(approx (- (log t) y) #s(hole binary64 (- (+ (log -1) (* -1 (log (/ -1 t)))) y)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) #s(hole binary64 (- (+ 1 (/ y z)) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) #s(hole binary64 (- (/ y z) (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (/ (log y) z)) (/ (neg (neg (log t))) z)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 t)) z)) (+ (/ (log -1) z) (/ (* x (log y)) z)))))
#s(approx (/ (neg (neg (log t))) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 t)))) z)))
#s(approx (neg (log t)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 t)))))))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y))
(*.f64 #s(literal -1 binary64) (+.f64 y (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) z)))
(neg.f64 (-.f64 y (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z))))
(fma.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) z) #s(literal -1 binary64) (neg.f64 y))
(fma.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z) (neg.f64 y))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) z) (neg.f64 y))
(fma.f64 #s(literal -1 binary64) y (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)))
(fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))
(fma.f64 y #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)))
(-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) (neg.f64 (neg.f64 y)))
(-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y)
(-.f64 (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) z)))
(-.f64 (neg.f64 y) (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z))))
(+.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) (neg.f64 y))
(+.f64 (neg.f64 y) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)))
(*.f64 #s(literal -1 binary64) z)
(*.f64 z #s(literal -1 binary64))
(neg.f64 z)
z
(neg.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64)))
(fma.f64 (+.f64 (neg.f64 (*.f64 (log.f64 y) x)) (neg.f64 (log.f64 t))) (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64))
(fma.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal -1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal 1 binary64))
(-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z)) (/.f64 (*.f64 (log.f64 y) x) z))
(-.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))))
(-.f64 #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(+.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(literal 1 binary64)
(*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (/.f64 #s(literal 1 binary64) z))
(/.f64 (fma.f64 (log.f64 t) z (*.f64 z (*.f64 (log.f64 y) x))) (*.f64 z z))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x (log.f64 t))) (neg.f64 z))
(/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)
(fma.f64 (/.f64 (neg.f64 (log.f64 t)) z) #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (log.f64 t) z))
(fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 t)) z) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) z) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (*.f64 (log.f64 y) x) (/.f64 #s(literal 1 binary64) z) (/.f64 (log.f64 t) z))
(fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (log.f64 t) z))
(-.f64 (/.f64 (*.f64 (log.f64 y) x) z) (neg.f64 (/.f64 (log.f64 t) z)))
(-.f64 (/.f64 (log.f64 t) z) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)))
(+.f64 (/.f64 (*.f64 (log.f64 y) x) z) (/.f64 (log.f64 t) z))
(+.f64 (/.f64 (log.f64 t) z) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (neg.f64 (log.f64 t)) #s(literal -1 binary64) (*.f64 (log.f64 y) x))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (log.f64 t))
(fma.f64 x (log.f64 y) (log.f64 t))
(-.f64 (log.f64 t) (*.f64 (neg.f64 x) (log.f64 y)))
(-.f64 (log.f64 t) (neg.f64 (*.f64 (log.f64 y) x)))
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (log.f64 t)))
(+.f64 (log.f64 t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (log.f64 t))
(log.f64 (fabs.f64 y))
(log.f64 y)
y
x
(*.f64 (neg.f64 (log.f64 t)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)))
(neg.f64 (neg.f64 (log.f64 t)))
(log.f64 (fabs.f64 t))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)))
(log.f64 t)
t
(*.f64 #s(literal -1 binary64) y)
(*.f64 y #s(literal -1 binary64))
(neg.f64 y)
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
(neg.f64 (-.f64 y #s(approx (+ (* (log y) x) (log t)) (log.f64 t))))
(-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y)
(+.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) (neg.f64 y))
#s(approx (+ (* (log y) x) (log t)) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
(*.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))))
(neg.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))))
(fma.f64 (neg.f64 (log.f64 t)) #s(literal -1 binary64) (-.f64 (*.f64 (log.f64 y) x) y))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (-.f64 (*.f64 (log.f64 y) x) y))
(fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y))
(fma.f64 x (log.f64 y) (-.f64 (log.f64 t) y))
(-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)
(-.f64 (log.f64 t) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) y)))
(-.f64 (*.f64 (log.f64 y) x) (neg.f64 (-.f64 (log.f64 t) y)))
(+.f64 (-.f64 (log.f64 t) y) (*.f64 (log.f64 y) x))
(+.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (neg.f64 y))
(+.f64 (log.f64 t) (-.f64 (*.f64 (log.f64 y) x) y))
(+.f64 (-.f64 (*.f64 (log.f64 y) x) y) (log.f64 t))
(+.f64 (*.f64 (log.f64 y) x) (-.f64 (log.f64 t) y))
(neg.f64 (-.f64 y (log.f64 t)))
(fma.f64 (neg.f64 (log.f64 t)) #s(literal -1 binary64) (neg.f64 y))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)) (neg.f64 y))
(fma.f64 #s(literal -1 binary64) y (log.f64 t))
(fma.f64 y #s(literal -1 binary64) (log.f64 t))
(-.f64 (log.f64 t) (*.f64 #s(literal 1 binary64) y))
(-.f64 (log.f64 t) (neg.f64 (neg.f64 y)))
(-.f64 (log.f64 t) y)
(+.f64 (neg.f64 y) (log.f64 t))
(+.f64 (log.f64 t) (neg.f64 y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal -1 binary64)) (neg.f64 z)))
(*.f64 (-.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal -1 binary64)) (neg.f64 z))
(*.f64 (neg.f64 z) (-.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal -1 binary64)))
(neg.f64 (*.f64 z (-.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal -1 binary64))))
(fma.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) (neg.f64 z) (*.f64 #s(literal 1 binary64) (neg.f64 z)))
(fma.f64 (neg.f64 z) #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) (*.f64 (neg.f64 z) #s(literal 1 binary64)))
(+.f64 (*.f64 (neg.f64 z) #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))) (*.f64 (neg.f64 z) #s(literal 1 binary64)))
(+.f64 (*.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) (neg.f64 z)) (*.f64 #s(literal 1 binary64) (neg.f64 z)))
(-.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal -1 binary64))
(+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
(*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal -1 binary64))
(*.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z))
(*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y)) z)
(/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) (neg.f64 z))
(/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z)
(neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
(fma.f64 (+.f64 (neg.f64 (*.f64 (log.f64 y) x)) (neg.f64 (log.f64 t))) (/.f64 #s(literal 1 binary64) z) (/.f64 y z))
(fma.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) #s(literal -1 binary64) (/.f64 y z))
(fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z) (/.f64 y z))
(fma.f64 y (/.f64 #s(literal 1 binary64) z) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(-.f64 (-.f64 (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (log.f64 t) z))
(-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 (/.f64 y z)))
(-.f64 (/.f64 (-.f64 y (log.f64 t)) z) (/.f64 (*.f64 (log.f64 y) x) z))
(-.f64 (/.f64 y z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
(+.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (/.f64 y z))
(+.f64 (/.f64 y z) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
(*.f64 y (/.f64 #s(literal 1 binary64) z))
(/.f64 (neg.f64 y) (neg.f64 z))
(/.f64 y z)
(*.f64 (fma.f64 (log.f64 y) x (log.f64 t)) (/.f64 #s(literal 1 binary64) z))
(/.f64 (fma.f64 (log.f64 t) z (*.f64 z (*.f64 (log.f64 y) x))) (*.f64 z z))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x (log.f64 t))) (neg.f64 z))
(/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)
(fma.f64 (/.f64 (neg.f64 (log.f64 t)) z) #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (log.f64 t) z))
(fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 t)) z) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) z) (/.f64 (*.f64 (log.f64 y) x) z))
(fma.f64 (*.f64 (log.f64 y) x) (/.f64 #s(literal 1 binary64) z) (/.f64 (log.f64 t) z))
(fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (log.f64 t) z))
(-.f64 (/.f64 (*.f64 (log.f64 y) x) z) (neg.f64 (/.f64 (log.f64 t) z)))
(-.f64 (/.f64 (log.f64 t) z) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)))
(+.f64 (/.f64 (*.f64 (log.f64 y) x) z) (/.f64 (log.f64 t) z))
(+.f64 (/.f64 (log.f64 t) z) (/.f64 (*.f64 (log.f64 y) x) z))
(*.f64 (log.f64 y) (/.f64 #s(literal 1 binary64) z))
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 z))
(/.f64 (log.f64 y) z)
(*.f64 (/.f64 (neg.f64 (log.f64 t)) z) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 t)) z))
(*.f64 (log.f64 t) (/.f64 #s(literal 1 binary64) z))
(/.f64 (neg.f64 (log.f64 t)) (neg.f64 z))
(/.f64 (log.f64 t) z)
(neg.f64 (/.f64 (neg.f64 (log.f64 t)) z))
(*.f64 (neg.f64 (log.f64 t)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 t)))
(neg.f64 (neg.f64 (log.f64 t)))
(log.f64 (fabs.f64 t))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)))
(log.f64 t)
(*.f64 #s(literal -1 binary64) (log.f64 t))
(*.f64 (log.f64 t) #s(literal -1 binary64))
(neg.f64 (log.f64 t))
(log.f64 (fabs.f64 (/.f64 #s(literal 1 binary64) t)))
(log.f64 (/.f64 #s(literal 1 binary64) 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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z)) (*.f64 (log.f64 y) x)))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (-.f64 (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z))) y))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (-.f64 (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z)) (*.f64 (log.f64 y) x)) y))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (+.f64 #s(literal 1 binary64) (-.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (log.f64 t) z))))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) 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 x x)
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (log.f64 t) y))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (+.f64 #s(literal 1 binary64) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (-.f64 y (log.f64 t)) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (log.f64 t)) z))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (+.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (-.f64 y (log.f64 t)) z)))
#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 (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (+.f64 (neg.f64 (*.f64 z (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z)) x))) (log.f64 y)) x))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z))) y) x)) x))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) z)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (*.f64 (-.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (log.f64 t) (*.f64 z x))) (/.f64 (log.f64 y) z)) x))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (*.f64 (log.f64 y) x) z))
#s(approx (/ (+ (* (log y) x) (log t)) z) (*.f64 (+.f64 (/.f64 (log.f64 t) (*.f64 z x)) (/.f64 (log.f64 y) z)) 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)) y) (*.f64 (+.f64 (log.f64 y) (/.f64 (-.f64 (log.f64 t) y) x)) x))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 y (*.f64 z x)) (/.f64 #s(literal 1 binary64) x)) (/.f64 (log.f64 t) (*.f64 z x))) (/.f64 (log.f64 y) z)) x))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (*.f64 (-.f64 (-.f64 (/.f64 y (*.f64 z x)) (/.f64 (log.f64 t) (*.f64 z x))) (/.f64 (log.f64 y) z)) x))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (-.f64 (log.f64 t) y) z) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (neg.f64 (*.f64 (fma.f64 z (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z)) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z))) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) z)) x)) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (neg.f64 (*.f64 (+.f64 (/.f64 (neg.f64 (log.f64 t)) (*.f64 z x)) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (+ (* (log y) x) (log t)) (neg.f64 (*.f64 (+.f64 (/.f64 (neg.f64 (log.f64 t)) x) (neg.f64 (log.f64 y))) x)))
#s(approx (- (+ (* (log y) x) (log t)) y) (neg.f64 (*.f64 (+.f64 (neg.f64 (/.f64 (-.f64 (log.f64 t) y) x)) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (log.f64 t)) z)) x)) (/.f64 (neg.f64 (log.f64 y)) z)) x)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (-.f64 y (log.f64 t)) z) x)) (/.f64 (neg.f64 (log.f64 y)) z)) 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 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) 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)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (log t) y) (-.f64 (log.f64 t) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (/ y z) (/.f64 y z))
#s(approx (/ (log y) z) (/.f64 (log.f64 y) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 (neg.f64 (/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)) z)) z) y)) #s(literal 1 binary64)) y))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)) z))
#s(approx (+ (* (log y) x) (log t)) (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) y))
#s(approx (- (log t) y) (*.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y)) (/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (*.f64 z y))) (/.f64 (log.f64 t) (*.f64 z y))) y))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (fma.f64 y (neg.f64 (/.f64 (/.f64 (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)) z) y)) (/.f64 y z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (+.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)) (log.f64 t)) z))
#s(approx (/ (log y) z) (neg.f64 (/.f64 (neg.f64 (log.f64 y)) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z) y)) #s(literal 1 binary64))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 y) (fma.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z)) y) #s(literal 1 binary64))))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)))
#s(approx (log y) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)))
#s(approx (- (+ (* (log y) x) (log t)) y) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) y)) #s(literal 1 binary64))))
#s(approx (- (log t) y) (*.f64 (neg.f64 y) (+.f64 (/.f64 (neg.f64 (log.f64 t)) y) #s(literal 1 binary64))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (*.f64 (neg.f64 y) (-.f64 (neg.f64 (/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z)) y)) (/.f64 #s(literal 1 binary64) z))))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (*.f64 (neg.f64 y) (-.f64 (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) (*.f64 z y)) (/.f64 #s(literal 1 binary64) z))))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) x (log.f64 t)) z))
#s(approx (/ (log y) z) (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) y))) #s(literal 0 binary64)) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) (log.f64 t)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (neg z) (neg.f64 z))
#s(approx z z)
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (/.f64 (-.f64 z (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 (+.f64 y (-.f64 z (fma.f64 (log.f64 y) x (log.f64 t)))) z))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64)) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z) #s(literal 1 binary64)) z))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (neg.f64 (/.f64 (-.f64 (-.f64 (neg.f64 y) (neg.f64 (log.f64 t))) (neg.f64 (*.f64 (log.f64 y) x))) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (neg.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y))
#s(approx t t)
#s(approx (neg (log t)) (neg.f64 (log.f64 t)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (-.f64 (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 z)) y))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (+ (* (log y) x) (log t)) (fma.f64 (log.f64 y) x (log.f64 t)))
#s(approx (log t) (log.f64 t))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
#s(approx (- (log t) y) (-.f64 (log.f64 t) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (/.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) z))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
#s(approx (/ (neg (neg (log t))) z) (/.f64 (log.f64 t) z))
#s(approx (neg (log t)) (neg.f64 (log.f64 t)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y) z))
#s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (*.f64 (neg.f64 z) (-.f64 (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z))))
#s(approx (+ (* (neg z) (- 1 (/ (+ (* (log y) x) (log t)) z))) (neg y)) (-.f64 (*.f64 (neg.f64 z) (-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z))) y))
#s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) (-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) z))
#s(approx (+ (* (log y) x) (log t)) (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)))
#s(approx (log t) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)))
#s(approx (- (+ (* (log y) x) (log t)) y) (-.f64 (+.f64 (fma.f64 (log.f64 y) x (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)))) #s(literal 0 binary64)) y))
#s(approx (- (log t) y) (-.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) y))
#s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 (-.f64 (+.f64 (/.f64 y z) #s(literal 1 binary64)) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z)))
#s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (-.f64 (/.f64 y z) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)) (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z)))
#s(approx (/ (+ (* (log y) x) (log t)) z) (+.f64 (/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 y) x)) z) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) z)))
#s(approx (/ (neg (neg (log t))) z) (/.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64)) z))
#s(approx (neg (log t)) (neg.f64 (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) t))) #s(literal 0 binary64))))

eval50.0ms (1.2%)

Memory
16.1MiB live, 97.8MiB allocated; 31ms collecting garbage
Compiler

Compiled 3 332 to 1 410 computations (57.7% saved)

prune105.0ms (2.6%)

Memory
-32.0MiB live, 43.4MiB allocated; 128ms collecting garbage
Pruning

21 alts after pruning (14 fresh and 7 done)

PrunedKeptTotal
New2684272
Fresh11011
Picked235
Done145
Total27221293
Accuracy
100.0%
Counts
293 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.0%
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
✓67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
72.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z))
✓67.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
✓40.8%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
✓77.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
✓62.4%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
78.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (fma.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64))))
77.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (*.f64 (log.f64 y) (/.f64 #s(literal 1 binary64) z)) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
17.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
60.7%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
28.9%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
23.2%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
68.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y)))) y))
✓33.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
✓29.3%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 y))
45.0%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
88.2%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (log.f64 t) z))) (neg.f64 y))))
72.5%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
60.4%
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
Compiler

Compiled 910 to 662 computations (27.3% saved)

regimes82.0ms (2%)

Memory
-5.8MiB live, 139.1MiB allocated; 18ms collecting garbage
Counts
34 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#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))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y))) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (log.f64 t)) z)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y) z)) #s(literal 1 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (fma.f64 (-.f64 y (fma.f64 (log.f64 y) x (log.f64 t))) (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (log.f64 t) z))) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (-.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)) (/.f64 (*.f64 (log.f64 y) x) z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) y) (*.f64 (fma.f64 y (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z) #s(literal -1 binary64)) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (*.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 x y)) (neg.f64 (/.f64 (log.f64 y) y))) x)) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (/.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) y)))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 (+.f64 (/.f64 (log.f64 t) y) (neg.f64 (*.f64 x (*.f64 (neg.f64 (log.f64 y)) (/.f64 #s(literal 1 binary64) y))))) #s(literal 1 binary64)) (/.f64 z y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) (+.f64 #s(approx (neg (/ (- (+ (* (log y) x) (log t)) y) z)) (-.f64 (/.f64 y z) (fma.f64 x (*.f64 (log.f64 y) (/.f64 #s(literal 1 binary64) z)) (/.f64 (neg.f64 (neg.f64 (log.f64 t))) z)))) #s(literal 1 binary64))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (neg.f64 (fma.f64 z (neg.f64 (/.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) y) #s(literal 1 binary64)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) y))) z)) (/.f64 z y)))) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (*.f64 (-.f64 (-.f64 (/.f64 (log.f64 t) (*.f64 z y)) (/.f64 (neg.f64 (*.f64 (log.f64 y) x)) (*.f64 z y))) (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) y))) z)) y))
Outputs
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 (+.f64 z y))) (log.f64 t))
Calls

8 calls:

15.0ms
t
10.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
10.0ms
x
9.0ms
(log.f64 t)
9.0ms
z
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 28 to 46 computations (-64.3% saved)

regimes52.0ms (1.3%)

Memory
-19.4MiB live, 77.3MiB allocated; 11ms collecting garbage
Counts
19 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#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))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
Outputs
(+.f64 (-.f64 (fma.f64 (log.f64 y) x (neg.f64 y)) z) (log.f64 t))
Calls

8 calls:

11.0ms
y
7.0ms
(log.f64 t)
6.0ms
t
6.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
5.0ms
z
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 28 to 46 computations (-64.3% saved)

regimes45.0ms (1.1%)

Memory
37.7MiB live, 82.8MiB allocated; 3ms collecting garbage
Counts
18 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#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))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Outputs
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Calls

8 calls:

7.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
5.0ms
(log.f64 t)
5.0ms
t
5.0ms
x
5.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 28 to 46 computations (-64.3% saved)

regimes50.0ms (1.2%)

Memory
-13.4MiB live, 82.2MiB allocated; 12ms collecting garbage
Counts
17 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#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))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
(+.f64 (fma.f64 (log.f64 y) x (neg.f64 #s(approx (+ z y) z))) (log.f64 t))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (-.f64 (-.f64 #s(approx (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) (/.f64 (log.f64 t) y)) #s(literal 1 binary64)) (/.f64 z y)) y))
Outputs
#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)) (fma.f64 (log.f64 y) x (-.f64 (log.f64 t) y)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
Calls

8 calls:

10.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
9.0ms
t
5.0ms
z
5.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
5.0ms
(log.f64 t)
Results
AccuracySegmentsBranch
81.6%4(log.f64 t)
91.8%3(-.f64 (*.f64 x (log.f64 y)) y)
90.3%3(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
90.2%3(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
92.1%3x
92.9%2y
95.7%3z
81.6%4t
Compiler

Compiled 28 to 46 computations (-64.3% saved)

regimes5.0ms (0.1%)

Memory
8.5MiB live, 8.5MiB allocated; 0ms 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#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))
#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)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
Calls

1 calls:

4.0ms
z
Results
AccuracySegmentsBranch
95.7%3z
Compiler

Compiled 1 to 4 computations (-300% saved)

regimes5.0ms (0.1%)

Memory
11.7MiB live, 11.7MiB allocated; 0ms collecting garbage
Counts
13 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 (fma.f64 (log.f64 y) x (log.f64 t)) y))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#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)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
Calls

1 calls:

4.0ms
z
Results
AccuracySegmentsBranch
95.2%3z
Compiler

Compiled 1 to 4 computations (-300% saved)

regimes27.0ms (0.7%)

Memory
-2.3MiB live, 43.2MiB allocated; 5ms collecting garbage
Counts
12 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#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 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (log.f64 t) y) z)))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) #s(approx (/ (+ (* (log y) x) (log t)) z) (/.f64 (log.f64 t) z))) (neg.f64 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

6 calls:

8.0ms
z
4.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
4.0ms
y
4.0ms
x
4.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Results
AccuracySegmentsBranch
75.8%3(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
75.8%3(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
83.1%2(-.f64 (*.f64 x (log.f64 y)) y)
85.8%3x
76.4%3y
72.5%1z
Compiler

Compiled 25 to 37 computations (-48% saved)

regimes30.0ms (0.7%)

Memory
-34.0MiB live, 12.7MiB allocated; 3ms 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (log.f64 y) x))
Calls

2 calls:

26.0ms
x
3.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
Results
AccuracySegmentsBranch
82.4%3(-.f64 (*.f64 x (log.f64 y)) y)
73.7%3x
Compiler

Compiled 6 to 11 computations (-83.3% saved)

regimes25.0ms (0.6%)

Memory
2.9MiB live, 49.3MiB allocated; 3ms collecting garbage
Counts
8 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (-.f64 #s(approx (+ (* (log y) x) (log t)) (log.f64 t)) y))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (- (- (log t) y) z) (-.f64 (log.f64 t) z)))
Calls

8 calls:

5.0ms
x
3.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
3.0ms
t
3.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
3.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
Results
AccuracySegmentsBranch
60.4%1x
71.7%3z
71.9%2(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
71.9%2(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
71.8%2y
60.4%1(log.f64 t)
60.4%1t
71.9%2(-.f64 (*.f64 x (log.f64 y)) y)
Compiler

Compiled 28 to 46 computations (-64.3% saved)

regimes12.0ms (0.3%)

Memory
24.3MiB live, 24.3MiB allocated; 0ms collecting garbage
Counts
6 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) (/.f64 (neg.f64 z) y)) y))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 (neg.f64 z) #s(approx (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1) (/.f64 y z))))
Outputs
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) #s(approx (* (neg z) (+ (neg (/ (- (+ (* (log y) x) (log t)) y) z)) 1)) (fma.f64 (neg.f64 z) #s(approx (- 1 (/ (+ (* (log y) x) (log t)) z)) #s(literal 1 binary64)) (neg.f64 y))))
Calls

5 calls:

2.0ms
(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
2.0ms
(-.f64 (*.f64 x (log.f64 y)) y)
2.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
2.0ms
y
2.0ms
z
Results
AccuracySegmentsBranch
60.4%1z
60.4%1y
60.4%1(-.f64 (*.f64 x (log.f64 y)) y)
60.4%1(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
60.4%1(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
Compiler

Compiled 24 to 33 computations (-37.5% saved)

regimes16.0ms (0.4%)

Memory
-21.2MiB live, 30.3MiB allocated; 5ms collecting garbage
Counts
3 → 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 (+ (- (- (* x (log y)) y) z) (log t)) (*.f64 #s(approx (- (- (+ (/ (log t) y) (neg (* x (/ (neg (log y)) y)))) 1) (/ z y)) #s(literal -1 binary64)) y))
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))
#s(approx (+ (- (- (* x (log y)) y) z) (log t)) (neg.f64 z))
Calls

8 calls:

5.0ms
z
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
x
2.0ms
(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
Results
AccuracySegmentsBranch
34.9%2(log.f64 t)
34.9%2t
36.4%3x
55.8%3z
46.7%2(-.f64 (*.f64 x (log.f64 y)) y)
44.9%2(-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z)
44.9%2(+.f64 (-.f64 (-.f64 (*.f64 x (log.f64 y)) y) z) (log.f64 t))
47.5%2y
Compiler

Compiled 28 to 46 computations (-64.3% saved)

regimes8.0ms (0.2%)

Memory
22.6MiB live, 22.6MiB allocated; 0ms 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:

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

Compiled 28 to 46 computations (-64.3% saved)

bsearch39.0ms (0.9%)

Memory
-14.3MiB live, 32.6MiB allocated; 2ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
11.0ms
4.286356891032317e+68
4.404578534201997e+70
25.0ms
-9.063249862275533e+76
-3.0222201278363085e+70
Samples
15.0ms256×0valid
Compiler

Compiled 627 to 620 computations (1.1% saved)

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

bsearch2.0ms (0%)

Memory
3.1MiB live, 3.1MiB allocated; 0ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
1.0ms
4.286356891032317e+68
4.404578534201997e+70
1.0ms
-9.063249862275533e+76
-3.0222201278363085e+70
Compiler

Compiled 627 to 620 computations (1.1% saved)

bsearch15.0ms (0.4%)

Memory
21.4MiB live, 21.4MiB allocated; 0ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
1.0ms
4.286356891032317e+68
4.404578534201997e+70
12.0ms
-9.063249862275533e+76
-3.0222201278363085e+70
Samples
7.0ms128×0valid
Compiler

Compiled 798 to 737 computations (7.6% saved)

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

bsearch94.0ms (2.3%)

Memory
-33.6MiB live, 56.6MiB allocated; 11ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
17.0ms
5.134642053167926e+176
6.329709983812439e+184
75.0ms
-5.880263791873031e+176
-9.99935162591912e+175
Samples
17.0ms240×0valid
Compiler

Compiled 419 to 452 computations (-7.9% saved)

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

bsearch0.0ms (0%)

Memory
0.8MiB live, 0.8MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
0.003953829751761691
31046799012328744.0
0.0ms
-3836224.3783010747
-119.8429353080282
Compiler

Compiled 13 to 17 computations (-30.8% saved)

bsearch0.0ms (0%)

Memory
0.6MiB live, 0.6MiB allocated; 0ms collecting garbage
Algorithm
1×left-value
Steps
TimeLeftRight
0.0ms
-3836224.3783010747
-119.8429353080282
Compiler

Compiled 13 to 17 computations (-30.8% saved)

bsearch7.0ms (0.2%)

Memory
13.6MiB live, 13.6MiB allocated; 0ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
6.0ms
8.96455940715954e+60
1.4863565964251108e+61
1.0ms
-9.063249862275533e+76
-3.0222201278363085e+70
Samples
4.0ms64×0valid
Compiler

Compiled 326 to 355 computations (-8.9% saved)

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

derivations349.0ms (8.5%)

Memory
5.9MiB live, 64.5MiB allocated; 36ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 158 to 88 computations (44.3% saved)

preprocess131.0ms (3.2%)

Memory
8.7MiB live, 201.0MiB allocated; 23ms collecting garbage
Remove

(abs t)

Compiler

Compiled 1 016 to 738 computations (27.4% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...