AI.Clustering.Hierarchical.Internal:ward from clustering-0.2.1

Time bar (total: 14.9s)

start0.0ms (0%)

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

analyze760.0ms (5.1%)

Memory
0.3MiB live, 438.6MiB allocated; 147ms collecting garbage
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.7%0.3%0%0%0%0
0%0%99.7%0.3%0%0%0%1
0%0%99.7%0.3%0%0%0%2
0%0%99.7%0.3%0%0%0%3
0%0%99.7%0.3%0%0%0%4
12.5%12.5%87.2%0.3%0%0%0%5
12.5%12.5%87.2%0.3%0%0%0%6
12.5%12.5%87.2%0.3%0%0%0%7
18.8%18.7%81%0.3%0%0%0%8
28.1%28%71.7%0.3%0%0%0%9
28.1%28%71.7%0.3%0%0%0%10
42.2%42.1%57.6%0.3%0%0%0%11
42.2%42.1%57.6%0.3%0%0%0%12
Compiler

Compiled 23 to 18 computations (21.7% saved)

sample2.4s (16.3%)

Memory
-25.9MiB live, 1 884.9MiB allocated; 1.4s collecting garbage
Samples
1.9s8 250×0valid
1.0ms5×1valid
0.0ms1×2valid
Precisions
Click to see histograms. Total time spent on operations: 1.2s
ival-mult!: 742.0ms (64% of total)
ival-add!: 191.0ms (16.5% of total)
ival-sub!: 170.0ms (14.7% of total)
ival-div!: 55.0ms (4.7% of total)
adjust: 2.0ms (0.2% of total)
Bogosity

preprocess40.0ms (0.3%)

Memory
6.0MiB live, 50.4MiB allocated; 8ms collecting garbage
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
0165614
1562607
22049603
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶58.9%
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 32 to 32 computations (0% saved)

series38.0ms (0.3%)

Memory
14.3MiB live, 59.2MiB allocated; 4ms collecting garbage
Counts
16 → 159
Calls
Call 1
Inputs
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b))
(+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a))
(*.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (+.f64 t y) a)
(+.f64 t y)
t
a
(*.f64 y b)
b
(+.f64 (+.f64 x t) y)
(+.f64 x t)
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y z)))))
#s(approx (* (+ x y) z) #s(hole binary64 (* y z)))
#s(approx (* (+ x y) z) #s(hole binary64 (+ (* x z) (* y z))))
#s(approx (+ x y) #s(hole binary64 y))
#s(approx (+ x y) #s(hole binary64 (+ x y)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* x z)))
#s(approx (* (+ x y) z) #s(hole binary64 (* x (+ z (/ (* y z) x)))))
#s(approx (+ x y) #s(hole binary64 x))
#s(approx (+ x y) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a (+ t y)) (* y z)) x)))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* y z) x)))))))
#s(approx (+ x y) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx y #s(hole binary64 y))
#s(approx (* (+ t y) a) #s(hole binary64 (* a t)))
#s(approx (* (+ t y) a) #s(hole binary64 (+ (* a t) (* a y))))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* y b) #s(hole binary64 (* b y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* y (+ z (/ (* x z) y)))))
#s(approx (+ x y) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (+ t y) a) #s(hole binary64 (* a y)))
#s(approx (* (+ t y) a) #s(hole binary64 (* y (+ a (/ (* a t) y)))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 z))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y))))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (* -1 (/ (* x z) y)))))))
#s(approx (+ x y) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (+ t y) a) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 (/ (* a t) y)))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (* (+ x y) z) #s(hole binary64 (* z (+ x y))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x (+ y (/ (* a (+ t y)) z))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (* a (+ t y)) z)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a y) (* z (+ x y)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* a y) (* z (+ x y))))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))))))
#s(approx (* (+ t y) a) #s(hole binary64 (* t (+ a (/ (* a y) t)))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* z (+ x y))) t)))))))
#s(approx (* (+ t y) a) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* a y) t)))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (* (+ t y) a) #s(hole binary64 (* a (+ t y))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t (+ y (/ (* z (+ x y)) a))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* z (+ x y)) a)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
Calls

18 calls:

TimeVariablePointExpression
5.0ms
y
@0
((/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* (+ x y) z) (+ x y) x y z (* (+ t y) a) (+ t y) t a (* y b) b (+ (+ x t) y) (+ x t))
4.0ms
y
@inf
((/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* (+ x y) z) (+ x y) x y z (* (+ t y) a) (+ t y) t a (* y b) b (+ (+ x t) y) (+ x t))
3.0ms
y
@-inf
((/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* (+ x y) z) (+ x y) x y z (* (+ t y) a) (+ t y) t a (* y b) b (+ (+ x t) y) (+ x t))
2.0ms
z
@0
((/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* (+ x y) z) (+ x y) x y z (* (+ t y) a) (+ t y) t a (* y b) b (+ (+ x t) y) (+ x t))
2.0ms
x
@inf
((/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* (+ x y) z) (+ x y) x y z (* (+ t y) a) (+ t y) t a (* y b) b (+ (+ x t) y) (+ x t))

rewrite732.0ms (4.9%)

Memory
-52.5MiB live, 580.6MiB allocated; 116ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
07745751
07915345
127215294
080105087
0358704714
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
175 → 583
Calls
Call 1
Inputs
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b))
(+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a))
(*.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (+.f64 t y) a)
(+.f64 t y)
t
a
(*.f64 y b)
b
(+.f64 (+.f64 x t) y)
(+.f64 x t)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y z)))))
#s(approx (* (+ x y) z) #s(hole binary64 (* y z)))
#s(approx (* (+ x y) z) #s(hole binary64 (+ (* x z) (* y z))))
#s(approx (+ x y) #s(hole binary64 y))
#s(approx (+ x y) #s(hole binary64 (+ x y)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* x z)))
#s(approx (* (+ x y) z) #s(hole binary64 (* x (+ z (/ (* y z) x)))))
#s(approx (+ x y) #s(hole binary64 x))
#s(approx (+ x y) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a (+ t y)) (* y z)) x)))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* y z) x)))))))
#s(approx (+ x y) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx y #s(hole binary64 y))
#s(approx (* (+ t y) a) #s(hole binary64 (* a t)))
#s(approx (* (+ t y) a) #s(hole binary64 (+ (* a t) (* a y))))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* y b) #s(hole binary64 (* b y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* y (+ z (/ (* x z) y)))))
#s(approx (+ x y) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (+ t y) a) #s(hole binary64 (* a y)))
#s(approx (* (+ t y) a) #s(hole binary64 (* y (+ a (/ (* a t) y)))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 z))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y))))))))
#s(approx (* (+ x y) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (* -1 (/ (* x z) y)))))))
#s(approx (+ x y) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (+ t y) a) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 (/ (* a t) y)))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (* (+ x y) z) #s(hole binary64 (* z (+ x y))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x (+ y (/ (* a (+ t y)) z))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (* a (+ t y)) z)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a y) (* z (+ x y)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* a y) (* z (+ x y))))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))))))
#s(approx (* (+ t y) a) #s(hole binary64 (* t (+ a (/ (* a y) t)))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* z (+ x y))) t)))))))
#s(approx (* (+ t y) a) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* a y) t)))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (* (+ t y) a) #s(hole binary64 (* a (+ t y))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t (+ y (/ (* z (+ x y)) a))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* z (+ x y)) a)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
Outputs
(/.f64 (-.f64 (*.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x))) (*.f64 (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)))) (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x))))
(/.f64 (-.f64 (*.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x))) (*.f64 (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))))) (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)) #s(literal 3 binary64))) (fma.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (fma.f64 (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) #s(literal 3 binary64)) (pow.f64 (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) #s(literal 3 binary64))) (fma.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (fma.f64 (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) (*.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (+.f64 (+.f64 t y) x) (*.f64 (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) y))) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64)))
(/.f64 (fma.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 b y))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (*.f64 (neg.f64 b) y) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))))) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64)))
(/.f64 (fma.f64 (*.f64 (neg.f64 b) y) (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (*.f64 (neg.f64 b) y) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (-.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))))) (pow.f64 (neg.f64 (+.f64 (+.f64 t y) x)) #s(literal 3 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (*.f64 (+.f64 y x) z) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (-.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))))) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64)))
(/.f64 (fma.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (-.f64 (*.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))))) (pow.f64 (neg.f64 (+.f64 (+.f64 t y) x)) #s(literal 3 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (fma.f64 z x (*.f64 y (-.f64 z b))))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 z x (*.f64 y (-.f64 z b))))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (*.f64 (+.f64 t y) a) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (-.f64 (*.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))))) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64)))
(/.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (fma.f64 z x (*.f64 y (-.f64 z b))))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) y))) (pow.f64 (neg.f64 (+.f64 (+.f64 t y) x)) #s(literal 3 binary64)))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (+.f64 (+.f64 t y) x)) (*.f64 (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 b y))) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64)))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))) (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 b y))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (neg.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 t y) x))
(neg.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(neg.f64 (fma.f64 b (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x)))))
(neg.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 x) y) (+.f64 (+.f64 t y) x)) z (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(neg.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) z (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(neg.f64 (/.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (neg.f64 (+.f64 (+.f64 t y) x))))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) (fabs.f64 (+.f64 (+.f64 t y) x))) (/.f64 (+.f64 (+.f64 t y) x) (fabs.f64 (+.f64 (+.f64 t y) x))) (fma.f64 (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) (fabs.f64 (+.f64 (+.f64 t y) x))) (/.f64 (+.f64 (+.f64 t y) x) (fabs.f64 (+.f64 (+.f64 t y) x))) (-.f64 (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a) (/.f64 (+.f64 (+.f64 t y) x) (neg.f64 (+.f64 (+.f64 t y) x))) (fma.f64 (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a) (/.f64 (+.f64 (+.f64 t y) x) (neg.f64 (+.f64 (+.f64 t y) x))) (-.f64 (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
(fma.f64 (/.f64 (+.f64 t y) (+.f64 (+.f64 t y) x)) a (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x)))
(fma.f64 (/.f64 t (+.f64 (+.f64 t y) x)) a (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) a (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(fma.f64 (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) #s(literal -1 binary64) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (fma.f64 (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (-.f64 (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x)))
(fma.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) z (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(fma.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(fma.f64 #s(literal -1 binary64) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
(fma.f64 b (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
(fma.f64 a (/.f64 (+.f64 t y) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x)))
(fma.f64 a (/.f64 t (+.f64 (+.f64 t y) x)) (fma.f64 a (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(fma.f64 z (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x)))
(fma.f64 z (/.f64 x (+.f64 (+.f64 t y) x)) (fma.f64 z (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 (neg.f64 y) z) (+.f64 (+.f64 t y) x)))
(-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x)))) (*.f64 (neg.f64 z) (/.f64 y (+.f64 (+.f64 t y) x))))
(-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)) z))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (/.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))) (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))))
(-.f64 (fma.f64 (/.f64 (+.f64 t y) (+.f64 (+.f64 t y) x)) a (/.f64 (*.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))) (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (neg.f64 (+.f64 (+.f64 t y) x))) (pow.f64 (neg.f64 (+.f64 (+.f64 t y) x)) #s(literal 3 binary64))) (/.f64 (*.f64 (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) y)) (pow.f64 (neg.f64 (+.f64 (+.f64 t y) x)) #s(literal 3 binary64))))
(-.f64 (/.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (+.f64 (+.f64 t y) x)) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64))) (/.f64 (*.f64 (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 b y)) (pow.f64 (+.f64 (+.f64 t y) x) #s(literal 3 binary64))))
(-.f64 (/.f64 (*.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (*.f64 b y)) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 b y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x)) (-.f64 (/.f64 (*.f64 (neg.f64 y) z) (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (-.f64 (/.f64 (*.f64 (neg.f64 y) a) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (+.f64 (+.f64 t y) x)))
(-.f64 (*.f64 a (/.f64 t (+.f64 (+.f64 t y) x))) (-.f64 (*.f64 (neg.f64 a) (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(-.f64 (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x))) (-.f64 (*.f64 (neg.f64 z) (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(-.f64 (*.f64 (/.f64 t (+.f64 (+.f64 t y) x)) a) (-.f64 (*.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)) a) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(-.f64 (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z) (-.f64 (*.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)) z) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x))))
(-.f64 (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (neg.f64 (+.f64 (+.f64 t y) x))))
(-.f64 (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) (+.f64 (+.f64 t y) x)))
(-.f64 (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) z (*.f64 b y)) (+.f64 (+.f64 t y) x)))
(+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x)))
(+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))) (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))))
(+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)))
(+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)))
(+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x))) (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (+.f64 (+.f64 t y) x)))
(+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)))
(+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x)))) (*.f64 z (/.f64 y (+.f64 (+.f64 t y) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) z))
(+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)))
(+.f64 (/.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (fma.f64 (/.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (*.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (-.f64 (/.f64 (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x))) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (+.f64 (+.f64 t y) x)) (-.f64 (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (+.f64 (+.f64 t y) x)) (-.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (*.f64 b (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (*.f64 z y) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 z x) (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (*.f64 a y) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)))))
(+.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (+.f64 (/.f64 (*.f64 a y) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (*.f64 a t) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 t y) x)))
(+.f64 (/.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(+.f64 (*.f64 a (/.f64 t (+.f64 (+.f64 t y) x))) (fma.f64 a (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x))) (fma.f64 z (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 (/.f64 t (+.f64 (+.f64 t y) x)) a) (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) a (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z) (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) z (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
(+.f64 (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x)))
(+.f64 (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a))) (*.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (-.f64 (neg.f64 x) y) z))) (+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 (-.f64 (neg.f64 x) y) z)))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))) (*.f64 (*.f64 b y) (*.f64 b y))) (+.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (*.f64 b y)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) #s(literal 3 binary64)) (pow.f64 (*.f64 (-.f64 (neg.f64 x) y) z) #s(literal 3 binary64))) (fma.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 (-.f64 (neg.f64 x) y) z)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) #s(literal 3 binary64)) (pow.f64 (*.f64 b y) #s(literal 3 binary64))) (fma.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (fma.f64 (*.f64 b y) (*.f64 b y) (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (*.f64 b y)))))
(neg.f64 (neg.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))))
(fma.f64 (*.f64 b y) #s(literal -1 binary64) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 (-.f64 (neg.f64 t) y) (neg.f64 a) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 (neg.f64 b) y (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 (neg.f64 y) (neg.f64 z) (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(fma.f64 (neg.f64 y) b (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 (-.f64 (neg.f64 x) y) (neg.f64 z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 a t (*.f64 (neg.f64 b) y)))
(fma.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a z) y (*.f64 z x)) (-.f64 (*.f64 a t) (*.f64 b y)))
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 y x) z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (fma.f64 a t (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 #s(literal 1 binary64) (*.f64 a t) (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 #s(literal 1 binary64) (*.f64 z x) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
(fma.f64 #s(literal 1 binary64) (*.f64 z y) (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) a) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 #s(literal 1 binary64) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (*.f64 (neg.f64 b) y))
(fma.f64 #s(literal -1 binary64) (*.f64 b y) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 x) z) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) a) (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 t) y) a) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 a z) y (*.f64 z x))) (fma.f64 a t (*.f64 (neg.f64 b) y)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 a z) y (*.f64 z x))) (-.f64 (*.f64 a t) (*.f64 b y)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))) (*.f64 (neg.f64 b) y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) z) (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 x) y) z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (fma.f64 a t (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 (+.f64 y x) z (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 b (neg.f64 y) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 a (-.f64 y (neg.f64 t)) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 a (-.f64 t (neg.f64 y)) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 y (-.f64 z b))))
(fma.f64 a t (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 a y (fma.f64 a t (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 t a (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 z (-.f64 x (neg.f64 y)) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 z (-.f64 y (neg.f64 x)) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 z (+.f64 y x) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(fma.f64 z y (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
(fma.f64 y (neg.f64 b) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(fma.f64 y a (fma.f64 a t (fma.f64 z x (*.f64 y (-.f64 z b)))))
(fma.f64 y z (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(fma.f64 x z (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
(-.f64 (+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 z x)) (*.f64 (neg.f64 y) z))
(-.f64 (+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 z y)) (*.f64 (neg.f64 x) z))
(-.f64 (fma.f64 (neg.f64 b) y (fma.f64 (+.f64 t y) a (*.f64 z x))) (*.f64 (neg.f64 y) z))
(-.f64 (fma.f64 (neg.f64 b) y (fma.f64 (+.f64 a z) y (*.f64 z x))) (*.f64 (neg.f64 t) a))
(-.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 y x) z)) (*.f64 (-.f64 (neg.f64 t) y) a))
(-.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 (-.f64 (neg.f64 x) y) z))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (-.f64 (*.f64 (neg.f64 y) z) (*.f64 (neg.f64 b) y)))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (fma.f64 (neg.f64 y) z (*.f64 b y)))
(-.f64 (*.f64 (neg.f64 b) y) (-.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (+.f64 y x) z)))
(-.f64 (*.f64 (neg.f64 b) y) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))))
(-.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (-.f64 (*.f64 (neg.f64 t) a) (*.f64 (neg.f64 b) y)))
(-.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 (neg.f64 t) a (*.f64 b y)))
(-.f64 (*.f64 (+.f64 y x) z) (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)))
(-.f64 (*.f64 a y) (-.f64 (*.f64 (neg.f64 t) a) (fma.f64 z x (*.f64 y (-.f64 z b)))))
(-.f64 (*.f64 a t) (-.f64 (*.f64 (neg.f64 y) a) (fma.f64 z x (*.f64 y (-.f64 z b)))))
(-.f64 (*.f64 z x) (-.f64 (*.f64 (neg.f64 y) z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(-.f64 (*.f64 z y) (-.f64 (*.f64 (neg.f64 x) z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(-.f64 (*.f64 (+.f64 t y) a) (fma.f64 (-.f64 (neg.f64 x) y) z (*.f64 b y)))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (*.f64 b y))
(+.f64 (fma.f64 (neg.f64 b) y (*.f64 a t)) (fma.f64 (+.f64 a z) y (*.f64 z x)))
(+.f64 (+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 z x)) (*.f64 z y))
(+.f64 (+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 z y)) (*.f64 z x))
(+.f64 (fma.f64 (neg.f64 b) y (fma.f64 (+.f64 t y) a (*.f64 z x))) (*.f64 z y))
(+.f64 (fma.f64 (neg.f64 b) y (fma.f64 (+.f64 a z) y (*.f64 z x))) (*.f64 a t))
(+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 y x) z)) (*.f64 (+.f64 t y) a))
(+.f64 (fma.f64 (neg.f64 b) y (*.f64 (+.f64 t y) a)) (*.f64 (+.f64 y x) z))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (*.f64 y (-.f64 z b)))
(+.f64 (*.f64 (neg.f64 b) y) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(+.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 a t (*.f64 (neg.f64 b) y)))
(+.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (-.f64 (*.f64 a t) (*.f64 b y)))
(+.f64 (*.f64 (+.f64 y x) z) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
(+.f64 (*.f64 a y) (fma.f64 a t (fma.f64 z x (*.f64 y (-.f64 z b)))))
(+.f64 (*.f64 a t) (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
(+.f64 (*.f64 z x) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
(+.f64 (*.f64 z y) (fma.f64 z x (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y))))
(+.f64 (*.f64 (+.f64 t y) a) (fma.f64 z x (*.f64 y (-.f64 z b))))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (*.f64 (neg.f64 b) y))
(*.f64 #s(literal 1 binary64) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
(*.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (fma.f64 (+.f64 t y) a (*.f64 z x))) (*.f64 (*.f64 (neg.f64 y) z) (*.f64 (neg.f64 y) z))) (+.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (*.f64 (neg.f64 y) z)))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 (+.f64 a z) y (*.f64 z x))) (*.f64 (*.f64 (neg.f64 t) a) (*.f64 (neg.f64 t) a))) (+.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (*.f64 (neg.f64 t) a)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 y x) z) (*.f64 (+.f64 y x) z)) (*.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (-.f64 (neg.f64 t) y) a))) (fma.f64 (+.f64 y x) z (*.f64 (-.f64 (neg.f64 t) y) a)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 t y) a) (*.f64 (+.f64 t y) a)) (*.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (-.f64 (neg.f64 x) y) z))) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 (neg.f64 x) y) z)))
(/.f64 (-.f64 (*.f64 (fma.f64 a t (*.f64 z x)) (fma.f64 a t (*.f64 z x))) (*.f64 (*.f64 (-.f64 (neg.f64 a) z) y) (*.f64 (-.f64 (neg.f64 a) z) y))) (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) z) y)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 y) z) #s(literal 3 binary64))) (fma.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (fma.f64 (+.f64 t y) a (*.f64 z x)) (fma.f64 (*.f64 (neg.f64 y) z) (*.f64 (neg.f64 y) z) (*.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (*.f64 (neg.f64 y) z)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 t) a) #s(literal 3 binary64))) (fma.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 (+.f64 a z) y (*.f64 z x)) (fma.f64 (*.f64 (neg.f64 t) a) (*.f64 (neg.f64 t) a) (*.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (*.f64 (neg.f64 t) a)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 y x) z) #s(literal 3 binary64)) (pow.f64 (*.f64 (-.f64 (neg.f64 t) y) a) #s(literal 3 binary64))) (fma.f64 (*.f64 (+.f64 y x) z) (*.f64 (+.f64 y x) z) (fma.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 t y) a) #s(literal 3 binary64)) (pow.f64 (*.f64 (-.f64 (neg.f64 x) y) z) #s(literal 3 binary64))) (fma.f64 (*.f64 (+.f64 t y) a) (*.f64 (+.f64 t y) a) (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (*.f64 (+.f64 t y) a) (*.f64 (-.f64 (neg.f64 x) y) z)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 a t (*.f64 z x)) #s(literal 3 binary64)) (pow.f64 (*.f64 (-.f64 (neg.f64 a) z) y) #s(literal 3 binary64))) (fma.f64 (fma.f64 a t (*.f64 z x)) (fma.f64 a t (*.f64 z x)) (fma.f64 (*.f64 (-.f64 (neg.f64 a) z) y) (*.f64 (-.f64 (neg.f64 a) z) y) (*.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) z) y)))))
(neg.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))))
(fma.f64 (neg.f64 (-.f64 (neg.f64 a) z)) y (fma.f64 a t (*.f64 z x)))
(fma.f64 (*.f64 (-.f64 (neg.f64 a) z) y) #s(literal -1 binary64) (fma.f64 a t (*.f64 z x)))
(fma.f64 (-.f64 (neg.f64 t) y) (neg.f64 a) (*.f64 (+.f64 y x) z))
(fma.f64 (neg.f64 y) (-.f64 (neg.f64 a) z) (fma.f64 a t (*.f64 z x)))
(fma.f64 (neg.f64 y) (neg.f64 z) (fma.f64 z x (*.f64 (+.f64 t y) a)))
(fma.f64 (neg.f64 y) (neg.f64 z) (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(fma.f64 (-.f64 (neg.f64 x) y) (neg.f64 z) (*.f64 (+.f64 t y) a))
(fma.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) #s(literal -1 binary64) (*.f64 (+.f64 a z) y))
(fma.f64 (-.f64 (neg.f64 a) z) (neg.f64 y) (fma.f64 a t (*.f64 z x)))
(fma.f64 (+.f64 a z) y (fma.f64 a t (*.f64 z x)))
(fma.f64 (fma.f64 a t (*.f64 z x)) #s(literal 1 binary64) (*.f64 (+.f64 a z) y))
(fma.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a z) y (*.f64 z x)) (*.f64 a t))
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 y x) z) (*.f64 (+.f64 t y) a))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (fma.f64 (+.f64 y x) z (*.f64 a t)))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (fma.f64 a t (*.f64 (+.f64 y x) z)))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (neg.f64 t) a)))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 x) y) z)))
(fma.f64 #s(literal 1 binary64) (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 a z) y))
(fma.f64 #s(literal 1 binary64) (*.f64 a t) (fma.f64 (+.f64 a z) y (*.f64 z x)))
(fma.f64 #s(literal 1 binary64) (*.f64 z x) (fma.f64 (+.f64 a z) y (*.f64 a t)))
(fma.f64 #s(literal 1 binary64) (*.f64 z x) (-.f64 (*.f64 (+.f64 a z) y) (*.f64 (neg.f64 t) a)))
(fma.f64 #s(literal 1 binary64) (*.f64 z x) (fma.f64 (+.f64 t y) a (*.f64 z y)))
(fma.f64 #s(literal 1 binary64) (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 z x))
(fma.f64 #s(literal 1 binary64) (*.f64 z y) (fma.f64 z x (*.f64 (+.f64 t y) a)))
(fma.f64 #s(literal 1 binary64) (*.f64 z y) (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) a) (*.f64 (+.f64 y x) z))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 a) z) y) (fma.f64 a t (*.f64 z x)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 x) z) (fma.f64 (+.f64 a z) y (*.f64 a t)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 x) z) (-.f64 (*.f64 (+.f64 a z) y) (*.f64 (neg.f64 t) a)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 x) z) (fma.f64 (+.f64 t y) a (*.f64 z y)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 z y))) (*.f64 z x))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) a) (fma.f64 (+.f64 a z) y (*.f64 z x)))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 t) y) a) (*.f64 (+.f64 y x) z))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 (+.f64 a z) y (*.f64 z x))) (*.f64 a t))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) z) (fma.f64 z x (*.f64 (+.f64 t y) a)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) z) (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 (+.f64 t y) a))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (fma.f64 (+.f64 y x) z (*.f64 a t)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (fma.f64 a t (*.f64 (+.f64 y x) z)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (neg.f64 t) a)))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 x) y) z)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (+.f64 a z) y))
(fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z))
(fma.f64 (+.f64 y x) z (*.f64 (+.f64 t y) a))
(fma.f64 a (-.f64 y (neg.f64 t)) (*.f64 (+.f64 y x) z))
(fma.f64 a (-.f64 t (neg.f64 y)) (*.f64 (+.f64 y x) z))
(fma.f64 a (+.f64 t y) (*.f64 (+.f64 y x) z))
(fma.f64 a t (fma.f64 (+.f64 a z) y (*.f64 z x)))
(fma.f64 a y (fma.f64 (+.f64 y x) z (*.f64 a t)))
(fma.f64 a y (fma.f64 a t (*.f64 (+.f64 y x) z)))
(fma.f64 a y (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (neg.f64 t) a)))
(fma.f64 a y (-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 x) y) z)))
(fma.f64 t a (fma.f64 (+.f64 a z) y (*.f64 z x)))
(fma.f64 z (-.f64 x (neg.f64 y)) (*.f64 (+.f64 t y) a))
(fma.f64 z (-.f64 y (neg.f64 x)) (*.f64 (+.f64 t y) a))
(fma.f64 z (+.f64 y x) (*.f64 (+.f64 t y) a))
(fma.f64 z y (fma.f64 z x (*.f64 (+.f64 t y) a)))
(fma.f64 z y (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(fma.f64 z x (fma.f64 (+.f64 a z) y (*.f64 a t)))
(fma.f64 z x (-.f64 (*.f64 (+.f64 a z) y) (*.f64 (neg.f64 t) a)))
(fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 z y)))
(fma.f64 y (-.f64 a (neg.f64 z)) (fma.f64 a t (*.f64 z x)))
(fma.f64 y (neg.f64 (-.f64 (neg.f64 a) z)) (fma.f64 a t (*.f64 z x)))
(fma.f64 y (+.f64 a z) (fma.f64 a t (*.f64 z x)))
(fma.f64 y a (fma.f64 (+.f64 y x) z (*.f64 a t)))
(fma.f64 y a (fma.f64 a t (*.f64 (+.f64 y x) z)))
(fma.f64 y a (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (neg.f64 t) a)))
(fma.f64 y a (-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 x) y) z)))
(fma.f64 y z (fma.f64 z x (*.f64 (+.f64 t y) a)))
(fma.f64 y z (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(fma.f64 x z (fma.f64 (+.f64 a z) y (*.f64 a t)))
(fma.f64 x z (-.f64 (*.f64 (+.f64 a z) y) (*.f64 (neg.f64 t) a)))
(fma.f64 x z (fma.f64 (+.f64 t y) a (*.f64 z y)))
(-.f64 (fma.f64 (+.f64 y x) z (*.f64 a t)) (*.f64 (neg.f64 y) a))
(-.f64 (fma.f64 a t (*.f64 (+.f64 y x) z)) (*.f64 (neg.f64 y) a))
(-.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 a y)) (*.f64 (neg.f64 y) z))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (*.f64 (neg.f64 y) z))
(-.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (*.f64 (neg.f64 t) a))
(-.f64 (*.f64 (+.f64 y x) z) (-.f64 (*.f64 (neg.f64 y) a) (*.f64 a t)))
(-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a))
(-.f64 (*.f64 a y) (-.f64 (*.f64 (-.f64 (neg.f64 x) y) z) (*.f64 a t)))
(-.f64 (*.f64 a y) (-.f64 (*.f64 (neg.f64 t) a) (*.f64 (+.f64 y x) z)))
(-.f64 (*.f64 a y) (fma.f64 (-.f64 (neg.f64 x) y) z (*.f64 (neg.f64 t) a)))
(-.f64 (*.f64 a y) (fma.f64 (neg.f64 t) a (*.f64 (-.f64 (neg.f64 x) y) z)))
(-.f64 (*.f64 (+.f64 a z) y) (-.f64 (*.f64 (neg.f64 x) z) (*.f64 a t)))
(-.f64 (*.f64 (+.f64 a z) y) (neg.f64 (fma.f64 a t (*.f64 z x))))
(-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) z) y))
(-.f64 (*.f64 a t) (-.f64 (*.f64 (neg.f64 y) a) (*.f64 (+.f64 y x) z)))
(-.f64 (*.f64 a t) (-.f64 (*.f64 (neg.f64 x) z) (*.f64 (+.f64 a z) y)))
(-.f64 (*.f64 a t) (fma.f64 (neg.f64 x) z (*.f64 (-.f64 (neg.f64 a) z) y)))
(-.f64 (*.f64 a t) (neg.f64 (fma.f64 (+.f64 a z) y (*.f64 z x))))
(-.f64 (*.f64 z x) (-.f64 (*.f64 (neg.f64 y) z) (*.f64 (+.f64 t y) a)))
(-.f64 (*.f64 z x) (-.f64 (*.f64 (-.f64 (neg.f64 a) z) y) (*.f64 a t)))
(-.f64 (*.f64 z x) (-.f64 (*.f64 (neg.f64 t) a) (*.f64 (+.f64 a z) y)))
(-.f64 (*.f64 z x) (fma.f64 (-.f64 (neg.f64 a) z) y (*.f64 (neg.f64 t) a)))
(-.f64 (*.f64 z x) (fma.f64 (neg.f64 t) a (*.f64 (-.f64 (neg.f64 a) z) y)))
(-.f64 (*.f64 z x) (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 z y))))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 (neg.f64 x) z))
(-.f64 (*.f64 z y) (-.f64 (*.f64 (neg.f64 x) z) (*.f64 (+.f64 t y) a)))
(-.f64 (*.f64 z y) (fma.f64 (neg.f64 x) z (*.f64 (-.f64 (neg.f64 t) y) a)))
(-.f64 (*.f64 (+.f64 t y) a) (-.f64 (*.f64 (neg.f64 x) z) (*.f64 z y)))
(-.f64 (*.f64 (+.f64 t y) a) (*.f64 (-.f64 (neg.f64 x) y) z))
(+.f64 (fma.f64 (+.f64 y x) z (*.f64 a t)) (*.f64 a y))
(+.f64 (fma.f64 a t (*.f64 (+.f64 y x) z)) (*.f64 a y))
(+.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 a y)) (*.f64 z y))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 z x)) (*.f64 z y))
(+.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) (*.f64 a t))
(+.f64 (*.f64 (+.f64 y x) z) (*.f64 (+.f64 t y) a))
(+.f64 (*.f64 a y) (fma.f64 (+.f64 y x) z (*.f64 a t)))
(+.f64 (*.f64 a y) (fma.f64 a t (*.f64 (+.f64 y x) z)))
(+.f64 (*.f64 a y) (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (neg.f64 t) a)))
(+.f64 (*.f64 a y) (-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 x) y) z)))
(+.f64 (*.f64 (+.f64 a z) y) (fma.f64 a t (*.f64 z x)))
(+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 a z) y))
(+.f64 (*.f64 a t) (fma.f64 (+.f64 a z) y (*.f64 z x)))
(+.f64 (*.f64 z x) (fma.f64 (+.f64 a z) y (*.f64 a t)))
(+.f64 (*.f64 z x) (-.f64 (*.f64 (+.f64 a z) y) (*.f64 (neg.f64 t) a)))
(+.f64 (*.f64 z x) (fma.f64 (+.f64 t y) a (*.f64 z y)))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 z x))
(+.f64 (*.f64 z y) (fma.f64 z x (*.f64 (+.f64 t y) a)))
(+.f64 (*.f64 z y) (-.f64 (*.f64 z x) (*.f64 (-.f64 (neg.f64 t) y) a)))
(+.f64 (*.f64 (+.f64 t y) a) (*.f64 (+.f64 y x) z))
(*.f64 (-.f64 (neg.f64 x) y) (neg.f64 z))
(*.f64 #s(literal 1 binary64) (*.f64 (+.f64 y x) z))
(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 x) y) z))
(*.f64 (+.f64 y x) z)
(*.f64 z (-.f64 x (neg.f64 y)))
(*.f64 z (-.f64 y (neg.f64 x)))
(*.f64 z (+.f64 y x))
(/.f64 (-.f64 (*.f64 (*.f64 z x) (*.f64 z x)) (*.f64 (*.f64 (neg.f64 y) z) (*.f64 (neg.f64 y) z))) (fma.f64 z x (*.f64 (neg.f64 y) z)))
(/.f64 (-.f64 (*.f64 (*.f64 z y) (*.f64 z y)) (*.f64 (*.f64 (neg.f64 x) z) (*.f64 (neg.f64 x) z))) (fma.f64 z y (*.f64 (neg.f64 x) z)))
(/.f64 (-.f64 (pow.f64 (*.f64 z x) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 y) z) #s(literal 3 binary64))) (fma.f64 (*.f64 z x) (*.f64 z x) (fma.f64 (*.f64 (neg.f64 y) z) (*.f64 (neg.f64 y) z) (*.f64 (*.f64 z x) (*.f64 (neg.f64 y) z)))))
(/.f64 (-.f64 (pow.f64 (*.f64 z y) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 x) z) #s(literal 3 binary64))) (fma.f64 (*.f64 z y) (*.f64 z y) (fma.f64 (*.f64 (neg.f64 x) z) (*.f64 (neg.f64 x) z) (*.f64 (*.f64 z y) (*.f64 (neg.f64 x) z)))))
(neg.f64 (*.f64 (-.f64 (neg.f64 x) y) z))
(fma.f64 (neg.f64 y) (neg.f64 z) (*.f64 z x))
(fma.f64 #s(literal 1 binary64) (*.f64 z x) (*.f64 z y))
(fma.f64 #s(literal 1 binary64) (*.f64 z y) (*.f64 z x))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 x) z) (*.f64 z y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) z) (*.f64 z x))
(fma.f64 z y (*.f64 z x))
(fma.f64 z x (*.f64 z y))
(fma.f64 y z (*.f64 z x))
(fma.f64 x z (*.f64 z y))
(-.f64 (*.f64 z x) (*.f64 (neg.f64 y) z))
(-.f64 (*.f64 z y) (*.f64 (neg.f64 x) z))
(+.f64 (*.f64 z x) (*.f64 z y))
(+.f64 (*.f64 z y) (*.f64 z x))
(*.f64 (-.f64 (neg.f64 x) y) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 y x))
(*.f64 #s(literal -1 binary64) (-.f64 (neg.f64 x) y))
(*.f64 (+.f64 y x) #s(literal 1 binary64))
(neg.f64 (-.f64 (neg.f64 x) y))
(+.f64 (neg.f64 (*.f64 x #s(literal -1 binary64))) y)
(+.f64 y x)
(+.f64 x y)
x
y
z
(*.f64 (-.f64 (neg.f64 t) y) (neg.f64 a))
(*.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) a))
(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 (neg.f64 t) y) a))
(*.f64 (+.f64 t y) a)
(*.f64 a (-.f64 y (neg.f64 t)))
(*.f64 a (-.f64 t (neg.f64 y)))
(*.f64 a (+.f64 t y))
(/.f64 (-.f64 (*.f64 (*.f64 a y) (*.f64 a y)) (*.f64 (*.f64 (neg.f64 t) a) (*.f64 (neg.f64 t) a))) (fma.f64 a y (*.f64 (neg.f64 t) a)))
(/.f64 (-.f64 (*.f64 (*.f64 a t) (*.f64 a t)) (*.f64 (*.f64 (neg.f64 y) a) (*.f64 (neg.f64 y) a))) (fma.f64 a t (*.f64 (neg.f64 y) a)))
(/.f64 (-.f64 (pow.f64 (*.f64 a y) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 t) a) #s(literal 3 binary64))) (fma.f64 (*.f64 a y) (*.f64 a y) (fma.f64 (*.f64 (neg.f64 t) a) (*.f64 (neg.f64 t) a) (*.f64 (*.f64 a y) (*.f64 (neg.f64 t) a)))))
(/.f64 (-.f64 (pow.f64 (*.f64 a t) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 y) a) #s(literal 3 binary64))) (fma.f64 (*.f64 a t) (*.f64 a t) (fma.f64 (*.f64 (neg.f64 y) a) (*.f64 (neg.f64 y) a) (*.f64 (*.f64 a t) (*.f64 (neg.f64 y) a)))))
(neg.f64 (*.f64 (-.f64 (neg.f64 t) y) a))
(fma.f64 #s(literal 1 binary64) (*.f64 a y) (*.f64 a t))
(fma.f64 #s(literal 1 binary64) (*.f64 a t) (*.f64 a y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) a) (*.f64 a y))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 y) a) (*.f64 a t))
(fma.f64 a t (*.f64 a y))
(fma.f64 a y (*.f64 a t))
(fma.f64 t a (*.f64 a y))
(fma.f64 y a (*.f64 a t))
(-.f64 (*.f64 a y) (*.f64 (neg.f64 t) a))
(-.f64 (*.f64 a t) (*.f64 (neg.f64 y) a))
(+.f64 (*.f64 a y) (*.f64 a t))
(+.f64 (*.f64 a t) (*.f64 a y))
(*.f64 (-.f64 (neg.f64 t) y) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 t y))
(*.f64 #s(literal -1 binary64) (-.f64 (neg.f64 t) y))
(*.f64 (+.f64 t y) #s(literal 1 binary64))
(neg.f64 (-.f64 (neg.f64 t) y))
(+.f64 (neg.f64 (*.f64 t #s(literal -1 binary64))) y)
(+.f64 t y)
(+.f64 y t)
t
a
(*.f64 (*.f64 b y) #s(literal 1 binary64))
(*.f64 (*.f64 (neg.f64 b) y) #s(literal -1 binary64))
(*.f64 (neg.f64 b) (neg.f64 y))
(*.f64 #s(literal 1 binary64) (*.f64 b y))
(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 b) y))
(*.f64 b y)
(*.f64 y b)
(neg.f64 (*.f64 (neg.f64 b) y))
b
(neg.f64 (neg.f64 (+.f64 (+.f64 t y) x)))
(fma.f64 (-.f64 (neg.f64 t) y) #s(literal -1 binary64) x)
(fma.f64 (-.f64 (neg.f64 x) y) #s(literal -1 binary64) t)
(fma.f64 #s(literal 1 binary64) (+.f64 t x) y)
(fma.f64 #s(literal 1 binary64) (+.f64 t y) x)
(fma.f64 #s(literal 1 binary64) (+.f64 y x) t)
(fma.f64 #s(literal -1 binary64) (neg.f64 (+.f64 t x)) y)
(fma.f64 #s(literal -1 binary64) (-.f64 (neg.f64 t) y) x)
(fma.f64 #s(literal -1 binary64) (-.f64 (neg.f64 x) y) t)
(fma.f64 (+.f64 t y) #s(literal 1 binary64) x)
(fma.f64 (+.f64 y x) #s(literal 1 binary64) t)
(+.f64 (+.f64 t x) y)
(+.f64 (+.f64 t y) x)
(+.f64 (+.f64 y x) t)
(+.f64 t (+.f64 y x))
(+.f64 y (+.f64 t x))
(+.f64 x (+.f64 t y))
(*.f64 #s(literal 1 binary64) (+.f64 t x))
(*.f64 #s(literal -1 binary64) (neg.f64 (+.f64 t x)))
(neg.f64 (neg.f64 (+.f64 t x)))
(+.f64 t x)
(+.f64 x t)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (+.f64 t y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (fma.f64 b (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (-.f64 (/.f64 z (+.f64 t y)) (fma.f64 y (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 a (+.f64 t y))))) x (/.f64 (*.f64 y (-.f64 z b)) (+.f64 t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 y (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y)))) (fma.f64 b (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))))) x (fma.f64 b (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 z (+.f64 t y)))) (fma.f64 y (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 a (+.f64 t y)))) x (/.f64 (*.f64 y (-.f64 z b)) (+.f64 t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 (fma.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))) (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (fma.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))))) x (fma.f64 y (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))))) (fma.f64 b (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))))) x (fma.f64 b (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 z (+.f64 t y)))) (fma.f64 y (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 a (+.f64 t y)))) x (/.f64 (*.f64 y (-.f64 z b)) (+.f64 t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 z y)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
#s(approx (* (+ x y) z) (*.f64 z y))
#s(approx (* (+ x y) z) (*.f64 (+.f64 y x) z))
#s(approx (+ x y) y)
#s(approx (+ x y) (+.f64 y x))
#s(approx x x)
#s(approx (+ (+ x t) y) (+.f64 t y))
#s(approx (+ (+ x t) y) (+.f64 (+.f64 t y) x))
#s(approx (+ x t) t)
#s(approx (+ x t) (+.f64 t x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (-.f64 z (/.f64 (*.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) (+.f64 t y)) (*.f64 x x))) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x) (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) (*.f64 (*.f64 x x) x)) z)) (fma.f64 (/.f64 (+.f64 t y) x) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z) (*.f64 b (/.f64 y x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) x)) x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x) z) x))
#s(approx (* (+ x y) z) (*.f64 z x))
#s(approx (* (+ x y) z) (*.f64 (fma.f64 y (/.f64 z x) z) x))
#s(approx (+ x y) x)
#s(approx (+ x y) (*.f64 (+.f64 (/.f64 y x) #s(literal 1 binary64)) x))
#s(approx (+ (+ x t) y) x)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) #s(literal 1 binary64)) x))
#s(approx (+ x t) x)
#s(approx (+ x t) (*.f64 (+.f64 (/.f64 t x) #s(literal 1 binary64)) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (neg.f64 x)) (*.f64 (/.f64 (+.f64 t y) x) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (-.f64 (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) (neg.f64 x)) (*.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) (+.f64 t y))) x) (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z))) x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) x))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x) z) x))
#s(approx (* (+ x y) z) (*.f64 (fma.f64 y (/.f64 z x) z) x))
#s(approx (+ x y) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 y) x) #s(literal 1 binary64))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 x) (-.f64 (/.f64 (-.f64 (neg.f64 t) y) x) #s(literal 1 binary64))))
#s(approx (+ x t) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 t) x) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 (-.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 y (+.f64 (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x)))) (-.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a t (*.f64 z x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 a t (*.f64 z x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
#s(approx y y)
#s(approx (* (+ t y) a) (*.f64 a t))
#s(approx (* (+ t y) a) (*.f64 (+.f64 t y) a))
#s(approx (+ t y) t)
#s(approx (+ t y) (+.f64 t y))
#s(approx (* y b) (*.f64 b y))
#s(approx (+ (+ x t) y) (+.f64 t x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) z) a) (fma.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (-.f64 z (-.f64 (/.f64 (*.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 a t (*.f64 z x)) y))) a) (fma.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (+.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 (*.f64 y y) y)) (/.f64 (fma.f64 a t (*.f64 z x)) y)) z) a) (fma.f64 (+.f64 t x) (+.f64 (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y)) (/.f64 (-.f64 (+.f64 a z) b) y)) b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) z) a) b) y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 a z) y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) z) a) y))
#s(approx (* (+ x y) z) (*.f64 (fma.f64 x (/.f64 z y) z) y))
#s(approx (+ x y) (*.f64 (+.f64 (/.f64 x y) #s(literal 1 binary64)) y))
#s(approx (* (+ t y) a) (*.f64 a y))
#s(approx (* (+ t y) a) (*.f64 (fma.f64 a (/.f64 t y) a) y))
#s(approx (+ t y) y)
#s(approx (+ t y) (*.f64 (+.f64 (/.f64 t y) #s(literal 1 binary64)) y))
#s(approx (+ (+ x t) y) y)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 (/.f64 (+.f64 t x) y) #s(literal 1 binary64)) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (/.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (/.f64 (+.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (/.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (/.f64 (+.f64 (fma.f64 a t (fma.f64 z x (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)) (*.f64 (+.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) (+.f64 t x))) y))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (-.f64 (-.f64 (/.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) y) z) (-.f64 a b))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 a z) y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) z) a) y))
#s(approx (* (+ x y) z) (*.f64 (fma.f64 x (/.f64 z y) z) y))
#s(approx (+ x y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 x) y) #s(literal 1 binary64))))
#s(approx (* (+ t y) a) (*.f64 (fma.f64 a (/.f64 t y) a) y))
#s(approx (+ t y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 t x) (neg.f64 y)) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) (+.f64 (+.f64 t y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 t y) x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 t y) a))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
#s(approx (* (+ x y) z) (*.f64 (+.f64 y x) z))
#s(approx z z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y (+.f64 x (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) z))) (+.f64 (+.f64 t y) x)) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y (+.f64 x (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) z))) z))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (fma.f64 a (/.f64 (+.f64 t y) z) (+.f64 y x)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y (+.f64 x (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 b y)) z))) (+.f64 (+.f64 t y) x)) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) z) (+.f64 y x)) (neg.f64 z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 (-.f64 (neg.f64 x) (fma.f64 a (/.f64 (+.f64 t y) z) y))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 y x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (fma.f64 (fma.f64 b (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (-.f64 (/.f64 a (+.f64 y x)) (fma.f64 a (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (/.f64 z (+.f64 y x))))) t (fma.f64 a (/.f64 y (+.f64 y x)) z)) (*.f64 b (/.f64 y (+.f64 y x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (fma.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 a (/.f64 y (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x))) (/.f64 z (*.f64 (+.f64 y x) (+.f64 y x)))) (fma.f64 b (/.f64 y (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x))) (/.f64 a (*.f64 (+.f64 y x) (+.f64 y x))))) t (fma.f64 b (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (/.f64 a (+.f64 y x)))) (fma.f64 a (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (/.f64 z (+.f64 y x)))) t (fma.f64 a (/.f64 y (+.f64 y x)) z)) (*.f64 b (/.f64 y (+.f64 y x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (fma.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 (fma.f64 b (/.f64 y (pow.f64 (+.f64 y x) #s(literal 4 binary64))) (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x))) (fma.f64 a (/.f64 y (pow.f64 (+.f64 y x) #s(literal 4 binary64))) (/.f64 z (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x)))))) t (fma.f64 a (/.f64 y (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x))) (/.f64 z (*.f64 (+.f64 y x) (+.f64 y x))))) (fma.f64 b (/.f64 y (*.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (+.f64 y x))) (/.f64 a (*.f64 (+.f64 y x) (+.f64 y x))))) t (fma.f64 b (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (/.f64 a (+.f64 y x)))) (fma.f64 a (/.f64 y (*.f64 (+.f64 y x) (+.f64 y x))) (/.f64 z (+.f64 y x)))) t (fma.f64 a (/.f64 y (+.f64 y x)) z)) (*.f64 b (/.f64 y (+.f64 y x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 a z) y (*.f64 z x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
#s(approx t t)
#s(approx (+ (+ x t) y) (+.f64 y x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) t) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (-.f64 a (/.f64 (*.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) (+.f64 y x)) (*.f64 t t))) (/.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (fma.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (/.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) (*.f64 (*.f64 t t) t)) (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) t)) a) (fma.f64 (+.f64 y x) (/.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) (*.f64 t t)) (/.f64 (fma.f64 b y (*.f64 (+.f64 y x) a)) t))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 a (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))) t)) t))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) t) a) t))
#s(approx (* (+ t y) a) (*.f64 (fma.f64 a (/.f64 y t) a) t))
#s(approx (+ t y) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) t))
#s(approx (+ (+ x t) y) t)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 (/.f64 (+.f64 y x) t) #s(literal 1 binary64)) t))
#s(approx (+ x t) (*.f64 (+.f64 (/.f64 x t) #s(literal 1 binary64)) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) t) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (/.f64 (*.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) (+.f64 y x)) t) (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a)))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (/.f64 (fma.f64 (*.f64 (+.f64 y x) (+.f64 y x)) (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a)))) t) (*.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a))) (+.f64 y x))) t) (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (*.f64 (+.f64 y x) a)))) t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 y (-.f64 z b)))) (neg.f64 t)) a)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (+.f64 a z) y (*.f64 z x)) t) a) t))
#s(approx (* (+ t y) a) (*.f64 (fma.f64 a (/.f64 y t) a) t))
#s(approx (+ t y) (*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 t) (-.f64 (/.f64 (-.f64 (neg.f64 x) y) t) #s(literal 1 binary64))))
#s(approx (+ x t) (*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 x) t) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) (+.f64 (+.f64 t y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 t y) x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b))))
#s(approx (* (+ t y) a) (*.f64 (+.f64 t y) a))
#s(approx a a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 (+.f64 t y) a) (+.f64 (+.f64 t y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) a))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (fma.f64 z (/.f64 (+.f64 y x) a) (+.f64 t y)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (-.f64 (neg.f64 t) y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (neg.f64 a)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 (-.f64 (neg.f64 t) (fma.f64 z (/.f64 (+.f64 y x) a) y))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 t y) x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))))
#s(approx b b)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) y) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (neg.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) (neg.f64 (-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) y))))

eval153.0ms (1%)

Memory
29.0MiB live, 87.1MiB allocated; 8ms collecting garbage
Compiler

Compiled 6 883 to 2 074 computations (69.9% saved)

prune126.0ms (0.8%)

Memory
-8.3MiB live, 38.0MiB allocated; 3ms collecting garbage
Pruning

25 alts after pruning (25 fresh and 0 done)

PrunedKeptTotal
New52525550
Fresh000
Picked101
Done000
Total52625551
Accuracy
100.0%
Counts
551 → 25
Alt Table
Click to see full alt table
StatusAccuracyProgram
34.8%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
29.5%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
▶34.3%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
59.1%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
47.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
34.8%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
44.4%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) z) (+.f64 y x)) (neg.f64 z))) (+.f64 (+.f64 x t) y))
30.7%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
27.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
▶18.2%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
14.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
▶98.9%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
48.3%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
40.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
52.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
▶32.2%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
42.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (fma.f64 b (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (-.f64 (/.f64 z (+.f64 t y)) (fma.f64 y (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 a (+.f64 t y))))) x (/.f64 (*.f64 y (-.f64 z b)) (+.f64 t y)))))
50.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
58.5%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
34.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
26.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
29.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
▶31.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
Compiler

Compiled 1 100 to 1 062 computations (3.5% saved)

series387.0ms (2.6%)

Memory
-1.6MiB live, 141.8MiB allocated; 23ms collecting garbage
Counts
38 → 553
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(neg.f64 b)
b
(/.f64 y (+.f64 (+.f64 t y) x))
y
(+.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
(*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)
(/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x))
(+.f64 y x)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y))
(*.f64 (neg.f64 b) y)
(+.f64 (+.f64 x t) y)
(+.f64 x t)
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t))
(*.f64 a t)
(*.f64 y b)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
(+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z)
(/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x)
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z))
(fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))
(*.f64 y (-.f64 z b))
(-.f64 z b)
(*.f64 (+.f64 t y) z)
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ 1 (+ t y)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (/ y (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ 1 (pow (+ t y) 3)) (/ y (pow (+ t y) 4)))) (/ y (pow (+ t y) 3))) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ y x) #s(hole binary64 y))
#s(approx (+ y x) #s(hole binary64 (+ x y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y z)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t y)) (pow x 2))) (/ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t y) 2)) (pow x 3)))) (+ (* -1 (/ (* t (+ t y)) (pow x 2))) (/ t x)))))
#s(approx (+ y x) #s(hole binary64 x))
#s(approx (+ y x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 y) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (* (+ t y) (- (* -1 y) (* -1 (+ t y)))) x))) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 y) (* -1 (+ t y)))) x)) (* -1 (* (+ t y) (- (* -1 y) (* -1 (+ t y)))))) x))) (* -1 (+ t y))) x)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a (+ t y)) (* y z)) x)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ x (+ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (/ 1 (+ t x)) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (/ x (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ 1 (pow (+ t x) 3)) (/ x (pow (+ t x) 4)))) (/ x (pow (+ t x) 3))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (* (neg b) y) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx (* y b) #s(hole binary64 (* b y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* a t) (* t z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x)) (/ (* t z) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (* a t) (* t z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a t) (* y (- a b))) (* t z))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a t) (* y (- (+ a z) b)))))
#s(approx (* y (- z b)) #s(hole binary64 (* y (- z b))))
#s(approx (* (+ t y) z) #s(hole binary64 (* t z)))
#s(approx (* (+ t y) z) #s(hole binary64 (+ (* t z) (* y z))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t x)) (pow y 2))) (/ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t x) 2)) (pow y 3)))) (+ (* -1 (/ (* t (+ t x)) (pow y 2))) (/ t y)))))
#s(approx (+ y x) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* y (- a b)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* y (- (+ (/ a x) (/ (* a t) (* x y))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* y (- a b))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* y (- (+ a (/ (* a t) y)) (+ b (/ (* t z) y))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- (+ a (+ z (/ (* a t) y))) b))))
#s(approx (* (+ t y) z) #s(hole binary64 (* y z)))
#s(approx (* (+ t y) z) #s(hole binary64 (* y (+ z (/ (* t z) y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 x) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (* (+ t x) (- (* -1 x) (* -1 (+ t x)))) y))) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 x) (* -1 (+ t x)))) y)) (* -1 (* (+ t x) (- (* -1 x) (* -1 (+ t x)))))) y))) (* -1 (+ t x))) y)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 z))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (/ (* a t) x) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 (- z b)) (* -1 (/ (- (* a t) (* t z)) y)))) (* -1 z))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 (- z b)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 (- z b)) (* -1 (/ (* a t) y))))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (* -1 (/ (* t z) y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (+ (* -1 (* b y)) (* a (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* t z) x)) (/ (* a (+ t y)) x)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (+ (* -1 (* b y)) (* a (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* -1 (* t z)) (* a (+ t y))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* -1 (* b y)) (* a (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* y z)))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (* y (- z b)) #s(hole binary64 (+ (* -1 (* b y)) (* y z))))
#s(approx (- z b) #s(hole binary64 (* -1 b)))
#s(approx (- z b) #s(hole binary64 (- z b)))
#s(approx (* (+ t y) z) #s(hole binary64 (* z (+ t y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x (+ y (/ (* a (+ t y)) z))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) z)) (/ (* a (+ t y)) z)) t))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y z)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* z (+ y (+ (* -1 (/ (* b y) z)) (/ (* a (+ t y)) z))))))
#s(approx (* y (- z b)) #s(hole binary64 (* y z)))
#s(approx (* y (- z b)) #s(hole binary64 (* z (+ y (* -1 (/ (* b y) z))))))
#s(approx (- z b) #s(hole binary64 z))
#s(approx (- z b) #s(hole binary64 (* z (+ 1 (* -1 (/ b z))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (* a (+ t y)) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* z (- (* -1 y) (* -1 (+ t y)))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (* -1 (/ (+ t y) x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* z (- (* -1 y) (* -1 (+ t y)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* z (- (+ (* -1 y) (* -1 (/ (+ (* -1 (* b y)) (* a (+ t y))) z))) (* -1 (+ t y)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* z (+ (* -1 y) (* -1 (/ (+ (* -1 (* b y)) (* a (+ t y))) z)))))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* z (+ (* -1 y) (/ (* b y) z))))))
#s(approx (- z b) #s(hole binary64 (* -1 (* z (- (/ b z) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t (+ x y))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (/ t (pow (+ x y) 2)) (/ 1 (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (* t (+ (* -1 (/ t (pow (+ x y) 3))) (/ 1 (pow (+ x y) 2)))) (/ 1 (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a y) (* z (+ x y)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* a y) (* z (+ x y))))))
#s(approx (* a t) #s(hole binary64 (* a t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a y) (* y (- z b))) (* y z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a y) (* y (- z b))) (* y z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a y) (+ (* t (- a z)) (* y (- z b)))) (* y z))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a y) (* y (- z b)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a t) (+ (* a y) (* y (- z b))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x y) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x (+ y (* -1 (/ (pow (+ x y) 2) t)))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (/ (pow (+ x y) 3) (pow t 2)))) (/ (pow (+ x y) 2) t)) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (* -1 (/ (pow (+ x y) 4) (pow t 3))))) (+ (* -1 (/ (pow (+ x y) 3) (pow t 2))) (/ (pow (+ x y) 2) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x)))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* t (- a z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* y (- z b)) t))) (+ z (/ (* y z) t))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* y (- z b)) t))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* t (+ z (/ (* y z) t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (/ (pow (+ x y) 2) t)) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (/ (pow (+ x y) 3) t) (pow (+ x y) 2)) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (* -1 (/ (- (/ (pow (+ x y) 4) t) (pow (+ x y) 3)) t)) (pow (+ x y) 2)) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* z (+ x y))) t)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t (- (* -1 a) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ (/ (* a y) x) (/ (* y (- z b)) x)) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t (- (* -1 a) (* -1 z))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t (- (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* y (- z b))) (* y z)) t))) (* -1 z))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* y (- z b))) t)))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* y z) t)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* y (- z b)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (* y (- z b)) (* z (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- z b))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a (+ t y)) (* y (- z b)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t (+ y (/ (* z (+ x y)) a))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (/ (* y (- z b)) (* a x)))) (/ (* z (+ t y)) (* a x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* a (- (+ t (+ y (/ (* y (- z b)) a))) (/ (* z (+ t y)) a)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a (+ t (+ y (/ (* y (- z b)) a))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* z (+ x y)) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (/ (* y (- z b)) x) (/ (* z (+ t y)) x)) a)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* y (- z b)) (* z (+ t y))) a)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* y (- z b)) a)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* z (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* -1 (* b y)) (+ (* a (+ t y)) (* y z))) (* z (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (- z b) #s(hole binary64 (+ z (* -1 b))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x)))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* b (- (+ (* -1 y) (+ (/ (* a (+ t y)) b) (/ (* y z) b))) (/ (* z (+ t y)) b)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* b (+ (* -1 y) (+ (/ (* a (+ t y)) b) (/ (* y z) b))))))
#s(approx (* y (- z b)) #s(hole binary64 (* b (+ (* -1 y) (/ (* y z) b)))))
#s(approx (- z b) #s(hole binary64 (* b (- (/ z b) 1))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ (/ (* a (+ t y)) x) (/ (* y z) x)) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) b)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (+ (* a (+ t y)) (* y z)) b)))))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (* y z) b)))))))
#s(approx (- z b) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ z b)))))))
Calls

18 calls:

TimeVariablePointExpression
99.0ms
z
@0
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (* (neg b) y) (+ (+ x t) y) (+ x t) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* a t) (* y b) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+ (* (+ t y) a) (* y (- z b))) (* y (- z b)) (- z b) (* (+ t y) z))
98.0ms
a
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (* (neg b) y) (+ (+ x t) y) (+ x t) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* a t) (* y b) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+ (* (+ t y) a) (* y (- z b))) (* y (- z b)) (- z b) (* (+ t y) z))
93.0ms
x
@inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (* (neg b) y) (+ (+ x t) y) (+ x t) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* a t) (* y b) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+ (* (+ t y) a) (* y (- z b))) (* y (- z b)) (- z b) (* (+ t y) z))
12.0ms
y
@inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (* (neg b) y) (+ (+ x t) y) (+ x t) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* a t) (* y b) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+ (* (+ t y) a) (* y (- z b))) (* y (- z b)) (- z b) (* (+ t y) z))
9.0ms
x
@0
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (* (neg b) y) (+ (+ x t) y) (+ x t) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (+ x y) z) (* (+ t y) a)) (* a t) (* y b) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+ (* (+ t y) a) (* y (- z b))) (* y (- z b)) (- z b) (* (+ t y) z))

rewrite1.1s (7.4%)

Memory
7.8MiB live, 759.9MiB allocated; 112ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0286423945
0291922501
0904220941
02933420304
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
591 → 769
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(neg.f64 b)
b
(/.f64 y (+.f64 (+.f64 t y) x))
y
(+.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
(*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)
(/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x))
(+.f64 y x)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y))
(*.f64 (neg.f64 b) y)
(+.f64 (+.f64 x t) y)
(+.f64 x t)
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t))
(*.f64 a t)
(*.f64 y b)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
(+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z)
(/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x)
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z))
(fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))
(*.f64 y (-.f64 z b))
(-.f64 z b)
(*.f64 (+.f64 t y) z)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ 1 (+ t y)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (/ y (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ 1 (pow (+ t y) 3)) (/ y (pow (+ t y) 4)))) (/ y (pow (+ t y) 3))) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ y x) #s(hole binary64 y))
#s(approx (+ y x) #s(hole binary64 (+ x y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y z)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t y)) (pow x 2))) (/ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t y) 2)) (pow x 3)))) (+ (* -1 (/ (* t (+ t y)) (pow x 2))) (/ t x)))))
#s(approx (+ y x) #s(hole binary64 x))
#s(approx (+ y x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* x (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 y) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (* (+ t y) (- (* -1 y) (* -1 (+ t y)))) x))) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 y) (* -1 (+ t y)))) x)) (* -1 (* (+ t y) (- (* -1 y) (* -1 (+ t y)))))) x))) (* -1 (+ t y))) x)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a (+ t y)) (* y z)) x)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ x (+ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (/ 1 (+ t x)) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (/ x (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ 1 (pow (+ t x) 3)) (/ x (pow (+ t x) 4)))) (/ x (pow (+ t x) 3))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (* (neg b) y) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx (* y b) #s(hole binary64 (* b y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* a t) (* t z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x)) (/ (* t z) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (* a t) (* t z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a t) (* y (- a b))) (* t z))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a t) (* y (- (+ a z) b)))))
#s(approx (* y (- z b)) #s(hole binary64 (* y (- z b))))
#s(approx (* (+ t y) z) #s(hole binary64 (* t z)))
#s(approx (* (+ t y) z) #s(hole binary64 (+ (* t z) (* y z))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t x)) (pow y 2))) (/ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t x) 2)) (pow y 3)))) (+ (* -1 (/ (* t (+ t x)) (pow y 2))) (/ t y)))))
#s(approx (+ y x) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* y (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* y (- a b)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* y (- (+ (/ a x) (/ (* a t) (* x y))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* y (- a b))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* y (- (+ a (/ (* a t) y)) (+ b (/ (* t z) y))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- (+ a (+ z (/ (* a t) y))) b))))
#s(approx (* (+ t y) z) #s(hole binary64 (* y z)))
#s(approx (* (+ t y) z) #s(hole binary64 (* y (+ z (/ (* t z) y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 x) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (* (+ t x) (- (* -1 x) (* -1 (+ t x)))) y))) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 x) (* -1 (+ t x)))) y)) (* -1 (* (+ t x) (- (* -1 x) (* -1 (+ t x)))))) y))) (* -1 (+ t x))) y)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 z))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (/ (* a t) x) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 (- z b)) (* -1 (/ (- (* a t) (* t z)) y)))) (* -1 z))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* y (+ (* -1 a) (* -1 (- z b)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* y (+ (* -1 a) (+ (* -1 (- z b)) (* -1 (/ (* a t) y))))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (* -1 (/ (* t z) y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (+ (* -1 (* b y)) (* a (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* t z) x)) (/ (* a (+ t y)) x)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (+ (* -1 (* b y)) (* a (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* -1 (* t z)) (* a (+ t y))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* -1 (* b y)) (* a (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* y z)))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (* y (- z b)) #s(hole binary64 (+ (* -1 (* b y)) (* y z))))
#s(approx (- z b) #s(hole binary64 (* -1 b)))
#s(approx (- z b) #s(hole binary64 (- z b)))
#s(approx (* (+ t y) z) #s(hole binary64 (* z (+ t y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* z (+ x (+ y (/ (* a (+ t y)) z))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) z)) (/ (* a (+ t y)) z)) t))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y z)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* z (+ y (+ (* -1 (/ (* b y) z)) (/ (* a (+ t y)) z))))))
#s(approx (* y (- z b)) #s(hole binary64 (* y z)))
#s(approx (* y (- z b)) #s(hole binary64 (* z (+ y (* -1 (/ (* b y) z))))))
#s(approx (- z b) #s(hole binary64 z))
#s(approx (- z b) #s(hole binary64 (* z (+ 1 (* -1 (/ b z))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (* a (+ t y)) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* z (- (* -1 y) (* -1 (+ t y)))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (* -1 (/ (+ t y) x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* z (- (* -1 y) (* -1 (+ t y)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* z (- (+ (* -1 y) (* -1 (/ (+ (* -1 (* b y)) (* a (+ t y))) z))) (* -1 (+ t y)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* z (+ (* -1 y) (* -1 (/ (+ (* -1 (* b y)) (* a (+ t y))) z)))))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* z (+ (* -1 y) (/ (* b y) z))))))
#s(approx (- z b) #s(hole binary64 (* -1 (* z (- (/ b z) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t (+ x y))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (/ t (pow (+ x y) 2)) (/ 1 (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (* t (+ (* -1 (/ t (pow (+ x y) 3))) (/ 1 (pow (+ x y) 2)))) (/ 1 (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a y) (* z (+ x y)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (+ (* a t) (+ (* a y) (* z (+ x y))))))
#s(approx (* a t) #s(hole binary64 (* a t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a y) (* y (- z b))) (* y z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a y) (* y (- z b))) (* y z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a y) (+ (* t (- a z)) (* y (- z b)))) (* y z))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a y) (* y (- z b)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a t) (+ (* a y) (* y (- z b))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x y) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x (+ y (* -1 (/ (pow (+ x y) 2) t)))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (/ (pow (+ x y) 3) (pow t 2)))) (/ (pow (+ x y) 2) t)) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (* -1 (/ (pow (+ x y) 4) (pow t 3))))) (+ (* -1 (/ (pow (+ x y) 3) (pow t 2))) (/ (pow (+ x y) 2) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a t)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x)))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* t (- a z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* y (- z b)) t))) (+ z (/ (* y z) t))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* t (+ a (+ (/ (* a y) t) (/ (* y (- z b)) t))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* t (+ z (/ (* y z) t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (/ (pow (+ x y) 2) t)) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (/ (pow (+ x y) 3) t) (pow (+ x y) 2)) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (* -1 (/ (- (/ (pow (+ x y) 4) t) (pow (+ x y) 3)) t)) (pow (+ x y) 2)) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* z (+ x y))) t)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t (- (* -1 a) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ (/ (* a y) x) (/ (* y (- z b)) x)) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t (- (* -1 a) (* -1 z))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* t (- (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* y (- z b))) (* y z)) t))) (* -1 z))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* a y) (* y (- z b))) t)))))))
#s(approx (* (+ t y) z) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* y z) t)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* y (- z b)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (* y (- z b)) (* z (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* y (- z b))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a (+ t y)) (* y (- z b)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* a (+ t (+ y (/ (* z (+ x y)) a))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (/ (* y (- z b)) (* a x)))) (/ (* z (+ t y)) (* a x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* a (- (+ t (+ y (/ (* y (- z b)) a))) (/ (* z (+ t y)) a)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* a (+ t (+ y (/ (* y (- z b)) a))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* z (+ x y)) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (/ (* y (- z b)) x) (/ (* z (+ t y)) x)) a)))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* y (- z b)) (* z (+ t y))) a)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (* y (- z b)) a)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* z (+ t y)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (- (+ (* -1 (* b y)) (+ (* a (+ t y)) (* y z))) (* z (+ t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (+ (* a (+ t y)) (* y z))))
#s(approx (- z b) #s(hole binary64 (+ z (* -1 b))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x)))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* b (- (+ (* -1 y) (+ (/ (* a (+ t y)) b) (/ (* y z) b))) (/ (* z (+ t y)) b)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* b (+ (* -1 y) (+ (/ (* a (+ t y)) b) (/ (* y z) b))))))
#s(approx (* y (- z b)) #s(hole binary64 (* b (+ (* -1 y) (/ (* y z) b)))))
#s(approx (- z b) #s(hole binary64 (* b (- (/ z b) 1))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ (/ (* a (+ t y)) x) (/ (* y z) x)) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) b)))))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (+ (* a (+ t y)) (* y z)) b)))))))
#s(approx (* y (- z b)) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (* y z) b)))))))
#s(approx (- z b) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ z b)))))))
Outputs
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) (fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a)))
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) (+.f64 (+.f64 t y) x)))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a)))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) (+.f64 (+.f64 t y) x)))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) (fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a)))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) (+.f64 (+.f64 t y) x)))
(-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x)))
(-.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (-.f64 (*.f64 (/.f64 (neg.f64 (+.f64 y x)) (+.f64 (+.f64 t y) x)) z) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a)))
(-.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (fma.f64 (/.f64 (neg.f64 (+.f64 y x)) (+.f64 (+.f64 t y) x)) z (/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x))))
(+.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (fma.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a)))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 t y) x))
(/.f64 (fma.f64 (*.f64 y (neg.f64 b)) (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) (*.f64 (+.f64 y x) z))) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) (/.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) (/.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)))
(-.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (*.f64 (/.f64 (neg.f64 (+.f64 y x)) (+.f64 (+.f64 t y) x)) z))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (/.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x)))
(*.f64 #s(literal -1 binary64) b)
(*.f64 b #s(literal -1 binary64))
(neg.f64 b)
b
(/.f64 (neg.f64 y) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 y (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 y (neg.f64 (+.f64 (+.f64 t y) x))))
(neg.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)))
y
(fma.f64 #s(literal 1 binary64) (+.f64 t y) x)
(+.f64 (+.f64 t y) x)
(+.f64 t (+.f64 y x))
(*.f64 #s(literal 1 binary64) (+.f64 t y))
(+.f64 t y)
t
x
(*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)
(*.f64 z (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (neg.f64 (+.f64 y x)) z) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (+.f64 y x) z) (+.f64 (+.f64 t y) x))
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) z (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z))
(fma.f64 z (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 z (/.f64 y (+.f64 (+.f64 t y) x))) (*.f64 z (/.f64 x (+.f64 (+.f64 t y) x))))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) z) (*.f64 (/.f64 x (+.f64 (+.f64 t y) x)) z))
(/.f64 (fma.f64 (neg.f64 y) (+.f64 (+.f64 t y) x) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) x)) (*.f64 (neg.f64 (+.f64 (+.f64 t y) x)) (+.f64 (+.f64 t y) x)))
(/.f64 (fma.f64 y (+.f64 (+.f64 t y) x) (*.f64 (+.f64 (+.f64 t y) x) x)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (neg.f64 (+.f64 y x)) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 (neg.f64 (+.f64 y x)) (+.f64 (+.f64 t y) x)))
(+.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (/.f64 x (+.f64 (+.f64 t y) x)))
(+.f64 y x)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(*.f64 a (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (neg.f64 (-.f64 (neg.f64 t) y)) a) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 y))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 (+.f64 (+.f64 t y) x))))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)))
(-.f64 (/.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (/.f64 y (+.f64 (+.f64 t y) x)))
(-.f64 (neg.f64 t) y)
(*.f64 #s(literal -1 binary64) t)
(*.f64 t #s(literal -1 binary64))
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
(/.f64 (neg.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b)))) (neg.f64 (+.f64 (+.f64 x t) y)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b))) (+.f64 (+.f64 x t) y))
(neg.f64 (/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b))) (neg.f64 (+.f64 (+.f64 x t) y))))
(neg.f64 (/.f64 (neg.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b)))) (+.f64 (+.f64 x t) y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b)))
(*.f64 (neg.f64 y) b)
(*.f64 (*.f64 y b) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 y b))
(*.f64 y (neg.f64 b))
(*.f64 (neg.f64 b) y)
(*.f64 b (neg.f64 y))
(neg.f64 (*.f64 y b))
(+.f64 (+.f64 x t) y)
(+.f64 x (+.f64 t y))
(+.f64 x t)
(/.f64 (-.f64 (*.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (+.f64 (+.f64 x t) y)) (*.f64 (+.f64 (+.f64 x t) y) (*.f64 y b))) (*.f64 (+.f64 (+.f64 x t) y) (+.f64 (+.f64 x t) y)))
(/.f64 (neg.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b))) (neg.f64 (+.f64 (+.f64 x t) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(neg.f64 (/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (neg.f64 (+.f64 (+.f64 x t) y))))
(neg.f64 (/.f64 (neg.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b))) (+.f64 (+.f64 x t) y)))
(-.f64 (/.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (+.f64 (+.f64 x t) y)) (/.f64 (*.f64 y b) (+.f64 (+.f64 x t) y)))
(+.f64 (/.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (+.f64 (+.f64 x t) y)) (/.f64 (*.f64 y (neg.f64 b)) (+.f64 (+.f64 x t) y)))
(-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b))
(+.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y (neg.f64 b)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t))
(*.f64 a t)
(*.f64 t a)
(*.f64 y b)
(*.f64 b y)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 (+.f64 t y) x) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 (neg.f64 a) x) (/.f64 (+.f64 t y) #s(literal -1 binary64)) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) x) #s(literal -1 binary64) z)
(fma.f64 (/.f64 (+.f64 t y) x) a (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) x) #s(literal 1 binary64) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t y) a) x) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) x) z)
(fma.f64 a (/.f64 (+.f64 t y) x) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) (-.f64 (/.f64 (*.f64 (+.f64 t y) z) x) z))
(+.f64 (/.f64 (*.f64 (+.f64 t y) a) x) (+.f64 (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x) z))
(+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x) z)
(*.f64 (/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) x) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) x))
(/.f64 (*.f64 (neg.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)))) #s(literal -1 binary64)) (neg.f64 x))
(/.f64 (*.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) #s(literal -1 binary64)) x)
(/.f64 (neg.f64 (neg.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))))) (neg.f64 x))
(/.f64 (-.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (*.f64 z y))) (fma.f64 (*.f64 y b) x (*.f64 x (*.f64 (+.f64 t y) z)))) (*.f64 x x))
(/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 t y)) a) (*.f64 x x) (*.f64 (neg.f64 x) (-.f64 (*.f64 (*.f64 (-.f64 z b) y) x) (*.f64 x (*.f64 (+.f64 t y) z))))) (*.f64 (*.f64 (neg.f64 x) x) x))
(/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 t y)) a) (neg.f64 x) (*.f64 (neg.f64 x) (neg.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z))))) (*.f64 x x))
(/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 t y)) a) x (*.f64 (neg.f64 x) (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))) (*.f64 (neg.f64 x) x))
(/.f64 (fma.f64 (*.f64 (+.f64 t y) a) (*.f64 x x) (*.f64 x (-.f64 (*.f64 (*.f64 (-.f64 z b) y) x) (*.f64 x (*.f64 (+.f64 t y) z))))) (*.f64 (*.f64 x x) x))
(/.f64 (fma.f64 (*.f64 (+.f64 t y) a) (neg.f64 x) (*.f64 x (neg.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z))))) (*.f64 (neg.f64 x) x))
(/.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))) (*.f64 x x))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (*.f64 z y))) (*.f64 x x)) (*.f64 (*.f64 x x) (fma.f64 (*.f64 y b) x (*.f64 x (*.f64 (+.f64 t y) z))))) (*.f64 (*.f64 x x) (*.f64 x x)))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (*.f64 z y))) x) (*.f64 (*.f64 x x) (fma.f64 y b (*.f64 (+.f64 t y) z)))) (*.f64 (*.f64 x x) x))
(/.f64 (-.f64 (*.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 z y))) (*.f64 x x)) (*.f64 (neg.f64 x) (fma.f64 (*.f64 y b) x (*.f64 x (*.f64 (+.f64 t y) z))))) (*.f64 (*.f64 (neg.f64 x) x) x))
(/.f64 (-.f64 (*.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 z y))) x) (*.f64 (neg.f64 x) (fma.f64 y b (*.f64 (+.f64 t y) z)))) (*.f64 (neg.f64 x) x))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 x x)) (*.f64 x (fma.f64 (*.f64 y b) x (*.f64 x (*.f64 (+.f64 t y) z))))) (*.f64 (*.f64 x x) x))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x) (*.f64 x (fma.f64 y b (*.f64 (+.f64 t y) z)))) (*.f64 x x))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (*.f64 (-.f64 z b) y))) (neg.f64 x)) (*.f64 (*.f64 x x) (*.f64 (neg.f64 z) (+.f64 t y)))) (*.f64 (*.f64 (neg.f64 x) x) x))
(/.f64 (-.f64 (*.f64 (fma.f64 (*.f64 (+.f64 t y) a) x (*.f64 x (*.f64 (-.f64 z b) y))) x) (*.f64 (*.f64 x x) (*.f64 (+.f64 t y) z))) (*.f64 (*.f64 x x) x))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (neg.f64 x)) (*.f64 x (*.f64 (neg.f64 z) (+.f64 t y)))) (*.f64 (neg.f64 x) x))
(/.f64 (-.f64 (*.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) (*.f64 x (*.f64 (+.f64 t y) z))) (*.f64 x x))
(/.f64 (neg.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)))) (neg.f64 (neg.f64 x)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)))) x)
(/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) (neg.f64 x))
(/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x)
(neg.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) (neg.f64 x)))
(neg.f64 (/.f64 (neg.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))) x))
(fma.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x) (/.f64 (*.f64 (neg.f64 z) (+.f64 t y)) x))
(fma.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 (+.f64 t y) x) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 (+.f64 t y) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) #s(literal -1 binary64)) (/.f64 (*.f64 (neg.f64 z) (+.f64 t y)) x))
(fma.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (*.f64 (+.f64 t y) a) #s(literal -1 binary64)) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (/.f64 (neg.f64 a) x) (/.f64 (+.f64 t y) #s(literal -1 binary64)) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (neg.f64 a) x) (/.f64 (+.f64 t y) #s(literal -1 binary64)) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) #s(literal 1 binary64) (/.f64 (*.f64 (neg.f64 z) (+.f64 t y)) x))
(fma.f64 (/.f64 (+.f64 t y) x) a (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (+.f64 t y) x) a (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (/.f64 t x) a (fma.f64 (/.f64 y x) a (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) x) #s(literal 1 binary64) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 (/.f64 (*.f64 (+.f64 t y) a) x) #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) (/.f64 (*.f64 (neg.f64 z) (+.f64 t y)) x))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t y) a) x) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t y) a) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 a (/.f64 (+.f64 t y) x) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(fma.f64 a (/.f64 (+.f64 t y) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 a (/.f64 t x) (fma.f64 (/.f64 y x) a (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)))
(-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) (/.f64 (*.f64 (+.f64 t y) z) x))
(-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x))
(+.f64 (*.f64 (/.f64 t x) a) (fma.f64 (/.f64 y x) a (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)))
(+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x) (/.f64 (*.f64 (neg.f64 z) (+.f64 t y)) x))
(+.f64 (/.f64 (*.f64 (+.f64 t y) a) x) (-.f64 (/.f64 (*.f64 z y) x) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)))
(+.f64 (/.f64 (*.f64 (+.f64 t y) a) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
(fma.f64 (+.f64 t y) a (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))
(fma.f64 a (+.f64 t y) (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))
(fma.f64 a t (fma.f64 (-.f64 (+.f64 a z) b) y (*.f64 (neg.f64 z) (+.f64 t y))))
(fma.f64 a t (fma.f64 a y (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z))))
(fma.f64 a t (-.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (*.f64 (+.f64 t y) z)))
(fma.f64 t a (fma.f64 (-.f64 (+.f64 a z) b) y (*.f64 (neg.f64 z) (+.f64 t y))))
(fma.f64 t a (fma.f64 a y (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z))))
(fma.f64 t a (-.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (*.f64 (+.f64 t y) z)))
(-.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 z t)) (*.f64 z y))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (fma.f64 y b (*.f64 (+.f64 t y) z)))
(-.f64 (*.f64 (+.f64 t y) a) (fma.f64 (neg.f64 y) (-.f64 z b) (*.f64 (+.f64 t y) z)))
(+.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 z t)) (*.f64 (neg.f64 z) y))
(+.f64 (*.f64 a t) (fma.f64 (-.f64 (+.f64 a z) b) y (*.f64 (neg.f64 z) (+.f64 t y))))
(+.f64 (*.f64 a t) (fma.f64 a y (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z))))
(+.f64 (*.f64 a t) (-.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (*.f64 (+.f64 t y) z)))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (neg.f64 z) (+.f64 t y)))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (+.f64 t y) z)))
(+.f64 (*.f64 (+.f64 t y) a) (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))
(fma.f64 (+.f64 t y) a (fma.f64 z y (*.f64 y (neg.f64 b))))
(fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))
(fma.f64 a (+.f64 t y) (fma.f64 z y (*.f64 y (neg.f64 b))))
(fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y))
(fma.f64 a t (*.f64 (-.f64 (+.f64 a z) b) y))
(fma.f64 t a (*.f64 (-.f64 (+.f64 a z) b) y))
(-.f64 (*.f64 a t) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) y))
(-.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 y b))
(-.f64 (*.f64 (+.f64 t y) a) (*.f64 (neg.f64 y) (-.f64 z b)))
(+.f64 (*.f64 a t) (*.f64 (-.f64 (+.f64 a z) b) y))
(+.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) (*.f64 y (neg.f64 b)))
(+.f64 (*.f64 (+.f64 t y) a) (fma.f64 z y (*.f64 y (neg.f64 b))))
(+.f64 (*.f64 (+.f64 t y) a) (*.f64 (-.f64 z b) y))
(*.f64 (-.f64 z b) y)
(*.f64 y (-.f64 z b))
(-.f64 (*.f64 z y) (*.f64 y b))
(*.f64 #s(literal 1 binary64) (-.f64 z b))
(-.f64 z b)
(+.f64 z (neg.f64 b))
(*.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) z))
(*.f64 (+.f64 t y) z)
(*.f64 z (-.f64 t (neg.f64 y)))
(*.f64 z (+.f64 t y))
(fma.f64 (*.f64 z t) #s(literal 1 binary64) (*.f64 (*.f64 z y) #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (*.f64 z t) (*.f64 #s(literal 1 binary64) (*.f64 z y)))
(fma.f64 z t (*.f64 z y))
(fma.f64 t z (*.f64 z y))
(-.f64 (*.f64 z t) (*.f64 (neg.f64 z) y))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 z t)) (*.f64 #s(literal 1 binary64) (*.f64 z y)))
(+.f64 (*.f64 (*.f64 z t) #s(literal 1 binary64)) (*.f64 (*.f64 z y) #s(literal 1 binary64)))
(+.f64 (*.f64 z t) (*.f64 z y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (+.f64 t y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 x (fma.f64 (-.f64 (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 t y) (+.f64 t y)))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y))))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (+.f64 t y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 x (fma.f64 (-.f64 (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (fma.f64 x (-.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (fma.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (neg.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 x y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) x (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 x (-.f64 (*.f64 (fma.f64 (neg.f64 x) (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 y (+.f64 t y))))
#s(approx (+ (+ t y) x) (+.f64 t y))
#s(approx (+ (+ t y) x) (+.f64 t (+.f64 x y)))
#s(approx x x)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 y (/.f64 z (+.f64 t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 x (fma.f64 (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 x (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))))) (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 y (+.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t y)) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) x (/.f64 y (+.f64 t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t y)) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))))) x (/.f64 y (+.f64 t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 x (-.f64 (fma.f64 x (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64)))) x (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 #s(literal 1 binary64) (+.f64 t y))) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 y (+.f64 t y))))
#s(approx (+ y x) y)
#s(approx (+ y x) (+.f64 x y))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 a (+.f64 #s(literal -1 binary64) (/.f64 x (+.f64 t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (/.f64 (neg.f64 a) (*.f64 (+.f64 t y) (+.f64 t y))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (+.f64 (/.f64 (neg.f64 a) (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 a x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(literal -1 binary64))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (/.f64 (neg.f64 x) (*.f64 (+.f64 t y) (+.f64 t y))) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (*.f64 (-.f64 (/.f64 x (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) x) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (+.f64 t y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (*.f64 y (/.f64 z (+.f64 t y))) (*.f64 b (/.f64 y (+.f64 t y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 z (+.f64 t y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (+ x t) y) (+.f64 t y))
#s(approx (+ (+ x t) y) (+.f64 t (+.f64 x y)))
#s(approx (+ x t) t)
#s(approx (+ x t) (+.f64 t x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 z y)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 (-.f64 z b) y))) (*.f64 (+.f64 t y) z)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) z)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (+.f64 z (/.f64 (*.f64 y (+.f64 (neg.f64 b) z)) x)) (/.f64 (fma.f64 (neg.f64 (+.f64 t y)) a (*.f64 (+.f64 t y) z)) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x))) (/.f64 (fma.f64 (neg.f64 a) (+.f64 t y) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (fma.f64 (/.f64 (+.f64 t y) (neg.f64 x)) a (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y)) a (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) (*.f64 (*.f64 x x) x)) (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)) (fma.f64 (*.f64 (+.f64 t y) z) (*.f64 x x) (*.f64 x (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y))))) (*.f64 (*.f64 x x) x))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 t y) y) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 t y) x) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (/.f64 (*.f64 (+.f64 t y) y) x)))) x))
#s(approx (+ (+ t y) x) x)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (neg.f64 (+.f64 t y)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 x x)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 (+.f64 z (fma.f64 y (/.f64 z x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(literal 1 binary64))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t y) t) (*.f64 x x))) (/.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (fma.f64 t (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 (*.f64 x x) x)) (fma.f64 (neg.f64 t) (/.f64 (+.f64 t y) (*.f64 x x)) (/.f64 t x)))))
#s(approx (+ y x) x)
#s(approx (+ y x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (+.f64 t y) x) (neg.f64 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (neg.f64 a) (+.f64 t y) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (neg.f64 (+.f64 t y)) a (/.f64 (fma.f64 (neg.f64 a) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) (*.f64 x x))))) (*.f64 a (+.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (+.f64 t y) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (+.f64 (neg.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y))) x))) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (neg.f64 (+.f64 t y)) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) (*.f64 x x)) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x)) (/.f64 (*.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x))) (/.f64 (fma.f64 y b (*.f64 (+.f64 t y) z)) x)) (/.f64 (*.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) (+.f64 t y)) (*.f64 x x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x)) x))
#s(approx (+ (+ x t) y) x)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (+ x t) x)
#s(approx (+ x t) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (-.f64 (*.f64 (neg.f64 y) (-.f64 z b)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (neg.f64 (*.f64 z (-.f64 (-.f64 y t) y))) (+.f64 t y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a))) x))) (-.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a)))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (fma.f64 (neg.f64 z) y (-.f64 (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (-.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) a))) x) (neg.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (neg.f64 (*.f64 z (-.f64 (-.f64 y t) y))) (+.f64 t y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a))))) x) (*.f64 y b)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a)))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (neg.f64 (*.f64 z (-.f64 (-.f64 y t) y))) (+.f64 t y))) x))) (fma.f64 y b (*.f64 (+.f64 t y) z))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (fma.f64 (neg.f64 z) y (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) x) (neg.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (neg.f64 (*.f64 z (-.f64 (-.f64 y t) y))) (+.f64 t y))))) x) (fma.f64 y b (*.f64 (+.f64 t y) z)))) x)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 t y) y) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y)))) (neg.f64 x)) (*.f64 (+.f64 t y) y)) x)) (neg.f64 x)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 z) y (fma.f64 (+.f64 t y) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 (+.f64 t y) z))) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 (neg.f64 (*.f64 z (-.f64 (-.f64 y t) y))) (+.f64 t y))) x))) (*.f64 (+.f64 t y) z)) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 y) (-.f64 (*.f64 (+.f64 t y) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x)) (+.f64 t y))) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 y) (-.f64 (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x) (*.f64 (neg.f64 (-.f64 (-.f64 y t) y)) (+.f64 t y))) x) (+.f64 t y))) x)))
#s(approx (+ y x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 y) x) #s(literal 1 binary64))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (*.f64 (neg.f64 (+.f64 t y)) a)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) a)) x) (*.f64 (+.f64 t y) a)) (neg.f64 x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (*.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y)) a)) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x) (*.f64 (neg.f64 (+.f64 t y)) a)) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (*.f64 (*.f64 (neg.f64 (+.f64 t y)) (+.f64 t y)) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (fma.f64 (+.f64 t y) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x) (*.f64 (+.f64 t y) z))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 t y) a (fma.f64 (-.f64 z b) y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x) (*.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) (neg.f64 (+.f64 t y)))) x)))) (*.f64 (+.f64 t y) z)) x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) x))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) #s(literal 1 binary64))))
#s(approx (+ x t) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 t) x) #s(literal 1 binary64))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 y (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x))))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 y (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t x)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (/.f64 (neg.f64 y) (*.f64 (+.f64 t x) (+.f64 t x))) y (/.f64 y (+.f64 t x))))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 y) (pow.f64 (+.f64 t x) #s(literal 4 binary64))) y (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx y y)
#s(approx (+ (+ t y) x) (+.f64 t x))
#s(approx (+ t y) t)
#s(approx (+ t y) (+.f64 t y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 x (/.f64 z (+.f64 t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 y (fma.f64 (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 y (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (*.f64 x (/.f64 z (+.f64 t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 x (+.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 x (+.f64 t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (fma.f64 (-.f64 (/.f64 x (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 x (+.f64 t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 y (-.f64 (fma.f64 y (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 x (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 x (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (+.f64 t x))) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 x (+.f64 t x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (neg.f64 a) (/.f64 t (+.f64 t x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 a (/.f64 t (+.f64 t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 t (+.f64 t x)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 t (+.f64 t x)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) y)) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (neg.f64 t) (+.f64 t x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 t (+.f64 t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y)) y)))
#s(approx (- (neg t) y) (neg.f64 t))
#s(approx (- (neg t) y) (-.f64 (neg.f64 y) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 y (+.f64 (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x)))) (-.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a t (*.f64 z x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a t (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (* (neg b) y) (*.f64 y (neg.f64 b)))
#s(approx (+ (+ x t) y) (+.f64 t x))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 a t (*.f64 z x)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 a t (fma.f64 z x (*.f64 (+.f64 a z) y))))
#s(approx (* y b) (*.f64 y b))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (-.f64 a b) y (*.f64 (-.f64 a z) t)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (-.f64 a b) y (*.f64 (-.f64 a z) t)) x))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (-.f64 (fma.f64 a t (*.f64 (-.f64 a b) y)) (*.f64 z t)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 a t))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)))
#s(approx (* y (- z b)) (*.f64 (-.f64 z b) y))
#s(approx (* (+ t y) z) (*.f64 z t))
#s(approx (* (+ t y) z) (*.f64 (+.f64 t y) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 z (-.f64 b (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 y y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (neg.f64 a)) (/.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 y y) y))) (+.f64 (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 b (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 t x) y)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 z (-.f64 (-.f64 x t) x)) (fma.f64 (*.f64 (+.f64 t x) z) (*.f64 y y) (*.f64 y (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x))))) (*.f64 (*.f64 y y) y))))
#s(approx (/ y (+ (+ t y) x)) #s(literal 1 binary64))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)))
#s(approx (/ y (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y (+.f64 t x))) (*.f64 y y))))
#s(approx (/ y (+ (+ t y) x)) (-.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (+ (+ t y) x) y)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)) y))
#s(approx (+ t y) y)
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t y)) y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (*.f64 y y)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 (+.f64 z (fma.f64 x (/.f64 z y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y)))) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t x) t) (*.f64 y y))) (/.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (fma.f64 t (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 (*.f64 y y) y)) (fma.f64 (neg.f64 t) (/.f64 (+.f64 t x) (*.f64 y y)) (/.f64 t y)))))
#s(approx (+ y x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x y)) y))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (*.f64 (*.f64 y y) y)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x y) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (/.f64 x y) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (+.f64 (/.f64 x y) (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) x) (*.f64 (*.f64 y y) y))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (neg.f64 y))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a z) (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y)) (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (+.f64 a z) (-.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) (/.f64 (*.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y))) b)) (*.f64 (+.f64 t x) (+.f64 (/.f64 (-.f64 (+.f64 a z) b) y) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) y))
#s(approx (+ (+ x t) y) y)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)) y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 a z) y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) y))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (-.f64 (/.f64 (+.f64 z (*.f64 (/.f64 t x) a)) y) (/.f64 b x))) (*.f64 t (/.f64 z (*.f64 x y)))) y))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 a b) y) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (+.f64 (/.f64 a x) (-.f64 (*.f64 a (/.f64 t (*.f64 x y))) (/.f64 b x))) (*.f64 t (/.f64 z (*.f64 x y)))) y))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a b) y))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (+.f64 a (-.f64 (-.f64 (*.f64 a (/.f64 t y)) b) (*.f64 t (/.f64 z y)))) y))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 (+.f64 a (+.f64 z (*.f64 a (/.f64 t y)))) b) y))
#s(approx (* (+ t y) z) (*.f64 z y))
#s(approx (* (+ t y) z) (*.f64 (+.f64 z (*.f64 t (/.f64 z y))) y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (fma.f64 (neg.f64 z) x (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (*.f64 (neg.f64 (+.f64 t x)) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x) (/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y))) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (*.f64 (neg.f64 z) x) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (fma.f64 (neg.f64 z) x (-.f64 (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b))))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) y) (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x)))) y) (+.f64 t x)) y)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 (+.f64 t x)) y) #s(literal 1 binary64))))
#s(approx (+ t y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 z) x (fma.f64 (+.f64 t x) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y) (*.f64 (+.f64 t x) z))) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) y))) (*.f64 (+.f64 t x) z)) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 x) (-.f64 (*.f64 (+.f64 t x) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y)) (+.f64 t x))) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y) (*.f64 (neg.f64 (-.f64 (-.f64 x t) x)) (+.f64 t x))) y) (+.f64 t x))) y)))
#s(approx (+ y x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 x) y) #s(literal 1 binary64))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 a (-.f64 (-.f64 t t) x)))) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 t x) y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) (neg.f64 y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (neg.f64 y) (+.f64 #s(literal 1 binary64) (/.f64 t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (fma.f64 (+.f64 t x) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x)))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (fma.f64 z x (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (*.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) (+.f64 t x))) y)))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (+.f64 (-.f64 (-.f64 (neg.f64 a) z) (/.f64 (fma.f64 a t (*.f64 z x)) y)) b)))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 (+.f64 t x)) y) #s(literal 1 binary64))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 y) (-.f64 (-.f64 (neg.f64 a) z) (/.f64 (fma.f64 a t (*.f64 z x)) y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 (neg.f64 a) (-.f64 (-.f64 z b) z)) y) (neg.f64 x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)) y)) (/.f64 z x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 (neg.f64 a) (-.f64 (-.f64 z b) z)) y) (neg.f64 x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) (-.f64 (-.f64 z b) z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 y) (+.f64 (-.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (/.f64 (*.f64 (-.f64 a z) t) y)) z)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (neg.f64 (-.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (*.f64 a (/.f64 t y)))) y))
#s(approx (* (+ t y) z) (*.f64 (neg.f64 y) (-.f64 (neg.f64 z) (*.f64 t (/.f64 z y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx z z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 t y) a))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z (/.f64 (*.f64 (+.f64 t y) a) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (+.f64 (/.f64 (neg.f64 (fma.f64 y b (*.f64 z t))) x) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (+.f64 (neg.f64 (fma.f64 y b (*.f64 z t))) (*.f64 (+.f64 t y) a)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 y (neg.f64 b) (fma.f64 (+.f64 t y) a (*.f64 z y))))
#s(approx (* y (- z b)) (*.f64 y (neg.f64 b)))
#s(approx (* y (- z b)) (*.f64 y (+.f64 (neg.f64 b) z)))
#s(approx (- z b) (neg.f64 b))
#s(approx (- z b) (-.f64 z b))
#s(approx (* (+ t y) z) (*.f64 (+.f64 t y) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) (+.f64 t (+.f64 x y)))) z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y)))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 x y) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 x (+.f64 y (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) z))) z))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 x y) z))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (*.f64 z x))) (/.f64 t x)) z))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (neg.f64 t) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (*.f64 z x))) z))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 z) t))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) z) t) z))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 z y))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (+.f64 y (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) z)) z))
#s(approx (* y (- z b)) (*.f64 z y))
#s(approx (* y (- z b)) (*.f64 (-.f64 y (/.f64 (*.f64 y b) z)) z))
#s(approx (- z b) z)
#s(approx (- z b) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 b z)) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 (+.f64 x y)) (+.f64 t (+.f64 x y))) (/.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (+.f64 t (+.f64 x y))) z))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 z) (/.f64 (+.f64 (neg.f64 (+.f64 x y)) (/.f64 (*.f64 y b) z)) (+.f64 t (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 (+.f64 x y)) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (+.f64 x y)) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) z))))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 (-.f64 (neg.f64 (+.f64 x y)) (/.f64 (*.f64 (+.f64 t y) a) z))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (-.f64 (/.f64 (neg.f64 y) x) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 z) (-.f64 (-.f64 (/.f64 (neg.f64 y) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (*.f64 z x))) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 y) x) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) (*.f64 z x)) (/.f64 (+.f64 t y) x)))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 z) (neg.f64 (-.f64 (-.f64 y t) y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 z) (-.f64 (neg.f64 y) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) z) (+.f64 t y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (neg.f64 z) (-.f64 (neg.f64 y) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 t y) a)) z))))
#s(approx (* y (- z b)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 y) (/.f64 (*.f64 y b) z))))
#s(approx (- z b) (*.f64 (neg.f64 z) (-.f64 (/.f64 b z) #s(literal 1 binary64))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 y (neg.f64 b)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))))) t (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (fma.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (*.f64 (-.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))))))) t (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (fma.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y)))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (fma.f64 t (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (fma.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))) (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y)))) t))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 x y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 t y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 t (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 y (+.f64 x y))))
#s(approx (+ (+ t y) x) (+.f64 x y))
#s(approx t t)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (*.f64 t (/.f64 z (+.f64 x y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t) (/.f64 z (+.f64 x y))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t (+.f64 x y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (*.f64 (-.f64 (/.f64 t (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (+.f64 x y))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (/.f64 (neg.f64 t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) t (-.f64 (/.f64 t (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (+.f64 x y)))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (neg.f64 a) (/.f64 y (+.f64 x y))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 y (+.f64 x y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 y (+.f64 x y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))))) t)) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (neg.f64 y) (+.f64 x y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 y) (+.f64 x y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 y) (+.f64 x y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) t (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y))))) t)) t)))
#s(approx (- (neg t) y) (-.f64 (neg.f64 t) y))
#s(approx (neg t) (neg.f64 t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 x y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (*.f64 a (/.f64 y (+.f64 x y))) (*.f64 b (/.f64 y (+.f64 x y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 a (+.f64 x y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (+ x t) y) (+.f64 x y))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 a y (*.f64 (+.f64 x y) z)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)))
#s(approx (* a t) (*.f64 a t))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (-.f64 a z) t (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z)))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (-.f64 a z) t (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z)))) x))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (fma.f64 a y (fma.f64 (-.f64 a z) t (*.f64 y (-.f64 (-.f64 z b) z)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) a)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (fma.f64 b (/.f64 (*.f64 (+.f64 x y) y) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) z) t))) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (/.f64 (fma.f64 (*.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t (*.f64 (*.f64 t t) (*.f64 (+.f64 x y) z)))) (*.f64 (*.f64 t t) t))) (neg.f64 a)) (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (neg.f64 (+.f64 x y))) z (*.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)))) (*.f64 (*.f64 t t) t))) (+.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (neg.f64 t)) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (-.f64 (fma.f64 (+.f64 x y) z (/.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t)) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t)))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (-.f64 (fma.f64 (+.f64 x y) z (*.f64 b (fma.f64 y (/.f64 (+.f64 x y) t) (*.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (*.f64 z (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t))))))) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) y) t)))) t))
#s(approx (+ (+ t y) x) t)
#s(approx (+ (+ t y) x) (+.f64 t (*.f64 t (/.f64 (+.f64 x y) t))))
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 z) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (*.f64 (+.f64 x y) z)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 z (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t))) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (-.f64 (fma.f64 (neg.f64 z) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t)) (*.f64 (+.f64 x y) z)) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t))) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 x y) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 x y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (-.f64 (-.f64 (+.f64 x y) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t))) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 (neg.f64 t) t))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (*.f64 (*.f64 t t) t)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x t) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (/.f64 x t) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (+.f64 (/.f64 x t) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) x) (*.f64 (*.f64 t t) t))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (neg.f64 (+.f64 x y)) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 t t)) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a (/.f64 (fma.f64 a y (*.f64 (+.f64 x y) z)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (*.f64 t t) t))) (/.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (+.f64 x y)) (*.f64 t t))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 a (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) t)) t))
#s(approx (+ (+ x t) y) t)
#s(approx (+ (+ x t) y) (+.f64 t (*.f64 t (/.f64 (+.f64 x y) t))))
#s(approx (+ x t) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x t)) t))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 a (/.f64 (fma.f64 a y (*.f64 (+.f64 x y) z)) t)) t))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (/.f64 (+.f64 z (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) x)) t)) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) (/.f64 z x))) t))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (+.f64 (/.f64 a x) (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (*.f64 x t))) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) (/.f64 z x))) t))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (+.f64 a (-.f64 (-.f64 (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) t) z) (*.f64 y (/.f64 z t)))) t))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (+.f64 a (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) t)) t))
#s(approx (* (+ t y) z) (*.f64 (+.f64 z (*.f64 y (/.f64 z t))) t))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b)) (*.f64 a y)) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (neg.f64 (+.f64 x y)) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (-.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) (*.f64 a y))) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y) (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)) (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z))) t))) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (-.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) (*.f64 a y))) t) a)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (neg.f64 (neg.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)) (neg.f64 t)) (*.f64 (*.f64 (+.f64 x y) y) b)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) y) b) (*.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) z)) t) (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)))) t) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 t)) (*.f64 (+.f64 x y) y)) t)) (neg.f64 t)))
#s(approx (+ (+ t y) x) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 x y)) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ t y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 z) (+.f64 x y) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 z (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t))) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (/.f64 (*.f64 z (-.f64 (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (neg.f64 t)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (neg.f64 t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 x y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 (+.f64 x y)) (/.f64 (-.f64 (/.f64 (-.f64 (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (neg.f64 t)) (*.f64 (+.f64 x y) (+.f64 x y))) t)) (neg.f64 t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (neg.f64 (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (neg.f64 (+.f64 x y)))) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 x y) t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) (neg.f64 t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) (neg.f64 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (neg.f64 (-.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (*.f64 (+.f64 x y) a))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (*.f64 (+.f64 x y) (/.f64 (neg.f64 (-.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (*.f64 (+.f64 x y) a))) t)) (*.f64 (+.f64 x y) a))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (/.f64 (neg.f64 (-.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (*.f64 (+.f64 x y) a))) t) (*.f64 (neg.f64 (-.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (*.f64 (+.f64 x y) a))) (+.f64 x y))) t) (*.f64 (+.f64 x y) a))) t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (neg.f64 a) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) t)) (neg.f64 t)))
#s(approx (+ (+ x t) y) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 x y)) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ x t) (*.f64 (-.f64 (/.f64 x (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (-.f64 (neg.f64 a) (/.f64 (fma.f64 a y (*.f64 (+.f64 x y) z)) t)) (neg.f64 t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (neg.f64 a) x) (-.f64 (/.f64 (+.f64 z (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x)) t) (/.f64 z x))) (neg.f64 t)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (/.f64 (neg.f64 a) x) (-.f64 (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) (*.f64 x t)) (/.f64 z x))) (neg.f64 t)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (neg.f64 (-.f64 a z)) (neg.f64 t)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) t) z)) (neg.f64 t)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 (neg.f64 a) (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) t)) (neg.f64 t)))
#s(approx (* (+ t y) z) (*.f64 (-.f64 (neg.f64 z) (*.f64 y (/.f64 z t))) (neg.f64 t)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z))) (+.f64 t (+.f64 x y))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (neg.f64 (+.f64 t y)) (+.f64 t (+.f64 x y))) a))
#s(approx a a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (+.f64 t y) a (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 (-.f64 z b) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)) x))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (-.f64 (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) z)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 z b) y))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 t y) a) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) a)) (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y)))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 (+.f64 t y) a) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t (+.f64 x y)) a))) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) a))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 t (+.f64 y (/.f64 (*.f64 (+.f64 x y) z) a))) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)) a)) a))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (+.f64 t y) a) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) (*.f64 a x))) a))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (+.f64 t y) a))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (+.f64 (+.f64 t y) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) a)) a))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (+.f64 t y) a))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (+.f64 t (+.f64 y (/.f64 (*.f64 (-.f64 z b) y) a))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 t y) a) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) a))) (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y)))) (neg.f64 a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 t y)) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t (+.f64 x y)) a))) (neg.f64 a)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (neg.f64 (+.f64 t y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) (neg.f64 a)))
#s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (neg.f64 (-.f64 (neg.f64 (+.f64 t y)) (/.f64 (*.f64 (+.f64 x y) z) a))) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) x)) a)) (neg.f64 a)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) (*.f64 a x))) (neg.f64 a)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 (neg.f64 (+.f64 t y)) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 (+.f64 t y) z)) a)) (neg.f64 a)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 (neg.f64 (+.f64 t y)) (/.f64 (*.f64 (-.f64 z b) y) a)) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (neg b) (neg.f64 b))
#s(approx b b)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 y (neg.f64 b) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z))) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 y (neg.f64 b) (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y)))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y)))) x))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y)))))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (fma.f64 (+.f64 t y) a (*.f64 z y)))
#s(approx (- z b) (-.f64 z b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (*.f64 (+.f64 t (+.f64 x y)) b))) b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (/.f64 (+.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) z) b)) (+.f64 t (+.f64 x y))) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) b))) b))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 y (neg.f64 b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)) b) y) b))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 y (neg.f64 b)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (/.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) x)) b)) b))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 y (neg.f64 b)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 x b))) b))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (+.f64 (neg.f64 y) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) b)) b))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 y (neg.f64 b)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (+.f64 (neg.f64 y) (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) b)) b))
#s(approx (* y (- z b)) (*.f64 (*.f64 y (+.f64 #s(literal -1 binary64) (/.f64 z b))) b))
#s(approx (- z b) (*.f64 (-.f64 (/.f64 z b) #s(literal 1 binary64)) b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 x y) z (*.f64 (+.f64 t y) a)) (*.f64 (+.f64 t (+.f64 x y)) b))) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 x y) (*.f64 (+.f64 t (+.f64 x y)) b)) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) b))) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 (-.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 x y) z)) b) y)) (neg.f64 b)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 z (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) x)) (neg.f64 b)) (/.f64 y x)) (neg.f64 b)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 x b))) (/.f64 y x)) (neg.f64 b)))
#s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 y (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z (-.f64 (-.f64 y t) y))) b)) (neg.f64 b)))
#s(approx (+ (* (+ t y) a) (* y (- z b))) (*.f64 (-.f64 y (/.f64 (fma.f64 (+.f64 t y) a (*.f64 z y)) b)) (neg.f64 b)))
#s(approx (* y (- z b)) (*.f64 (-.f64 y (*.f64 y (/.f64 z b))) (neg.f64 b)))
#s(approx (- z b) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 z b)) (neg.f64 b)))

eval108.0ms (0.7%)

Memory
-1.6MiB live, 251.3MiB allocated; 43ms collecting garbage
Compiler

Compiled 14 080 to 4 125 computations (70.7% saved)

prune38.0ms (0.3%)

Memory
16.0MiB live, 107.0MiB allocated; 8ms collecting garbage
Pruning

39 alts after pruning (38 fresh and 1 done)

PrunedKeptTotal
New71627743
Fresh91120
Picked415
Done000
Total72939768
Accuracy
100.0%
Counts
768 → 39
Alt Table
Click to see full alt table
StatusAccuracyProgram
34.8%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
11.9%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
▶59.1%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
47.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 x t) y))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
27.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
7.8%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
8.4%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
8.6%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
14.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
▶85.9%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
77.5%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
33.0%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) t)) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) t)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) t)) a))
70.1%
(-.f64 (fma.f64 (neg.f64 b) #s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
65.3%
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
62.2%
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x)))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
63.3%
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
▶40.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
27.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
29.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
▶25.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
34.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x)))) z))
50.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
58.5%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
34.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
63.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
26.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
6.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
11.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
9.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
25.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
▶29.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
✓31.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
52.4%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
49.9%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
61.3%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) (+.f64 t (+.f64 x y)))) z))
Compiler

Compiled 2 023 to 1 859 computations (8.1% saved)

series193.0ms (1.3%)

Memory
13.8MiB live, 195.0MiB allocated; 35ms collecting garbage
Counts
36 → 512
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(neg.f64 b)
b
(/.f64 y (+.f64 (+.f64 t y) x))
y
(+.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
(+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z)
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z))
(*.f64 (/.f64 (neg.f64 t) x) z)
(/.f64 (neg.f64 t) x)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
(/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))
(fma.f64 a t (*.f64 z x))
(*.f64 z x)
(+.f64 t x)
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))
(fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))
(-.f64 (+.f64 a z) b)
(+.f64 a z)
(+.f64 (+.f64 x t) y)
(+.f64 x t)
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (* (/ (neg t) x) z) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (neg t) x) #s(hole binary64 (* -1 (/ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (/ z t) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (/ a (pow t 2)) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (+ (* x (- (/ z (pow t 3)) (/ a (pow t 3)))) (/ a (pow t 2))) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a t)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (* z x) #s(hole binary64 (* x z)))
#s(approx (+ t x) #s(hole binary64 t))
#s(approx (+ t x) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* y (- (+ a z) b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* t (- (* a t) (* t z))) (pow x 2))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (/ (* a t) x) (/ (* (pow t 2) (- (* a t) (* t z))) (pow x 3)))) (+ (/ (* t z) x) (/ (* t (- (* a t) (* t z))) (pow x 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x z)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x (+ z (/ (* a t) x)))))
#s(approx (+ t x) #s(hole binary64 x))
#s(approx (+ t x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* x z)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* x (+ z (+ (/ (* a t) x) (/ (* y (- (+ a z) b)) x))))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* a t)) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (* t (- (* -1 (* a t)) (* -1 (* t z)))) x))) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (- (* -1 (/ (* (pow t 2) (- (* -1 (* a t)) (* -1 (* t z)))) x)) (* -1 (* t (- (* -1 (* a t)) (* -1 (* t z)))))) x))) (* -1 (* t z))) x)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* a t) x)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a t) (* y (- (+ a z) b))) x)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* a t) (* t z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x)) (/ (* t z) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* y (- a b)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* y (- (+ (/ a x) (/ (* a t) (* x y))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (/ (* a t) x) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* y (+ (* -1 (- (+ a z) b)) (* -1 (/ (+ (* a t) (* x z)) y)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (+ (* -1 (* b y)) (* a (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* t z) x)) (/ (* a (+ t y)) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* a t) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* y (- a b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* y (- a b)) (* z (+ x y))))))
#s(approx (- (+ a z) b) #s(hole binary64 (- a b)))
#s(approx (- (+ a z) b) #s(hole binary64 (- (+ a z) b)))
#s(approx (+ a z) #s(hole binary64 a))
#s(approx (+ a z) #s(hole binary64 (+ a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* z (+ (/ x (+ t x)) (/ (* a t) (* z (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* z (+ x (/ (* a t) z)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* z (+ x (+ y (+ (/ (* a t) z) (/ (* y (- a b)) z)))))))
#s(approx (- (+ a z) b) #s(hole binary64 z))
#s(approx (- (+ a z) b) #s(hole binary64 (* z (- (+ 1 (/ a z)) (/ b z)))))
#s(approx (+ a z) #s(hole binary64 z))
#s(approx (+ a z) #s(hole binary64 (* z (+ 1 (/ a z)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* z (- (* -1 y) (* -1 (+ t y)))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (* -1 (/ (+ t y) x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ x (+ t x))) (* -1 (/ (* a t) (* z (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 (/ (* a t) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* z (+ (* -1 x) (+ (* -1 y) (* -1 (/ (+ (* a t) (* y (- a b))) z))))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* z (- (* -1 (/ (- a b) z)) 1)))))
#s(approx (+ a z) #s(hole binary64 (* -1 (* z (- (* -1 (/ a z)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a y) (* y (- z b))) (* y z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (/ a x) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (/ z (pow x 2)) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (+ (* t (- (/ a (pow x 3)) (/ z (pow x 3)))) (/ z (pow x 2))) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* x z) (* y (- (+ a z) b)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x)))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (/ (* x z) t)) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* x (- (* x z) (* a x))) (pow t 2))) (/ (* x z) t))) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (/ (* x z) t) (/ (* (pow x 2) (- (* x z) (* a x))) (pow t 3)))) (+ (/ (* a x) t) (/ (* x (- (* x z) (* a x))) (pow t 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* t (+ a (/ (* x z) t)))))
#s(approx (+ t x) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a t)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* t (+ a (+ (/ (* x z) t) (/ (* y (- (+ a z) b)) t))))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t (- (* -1 a) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ (/ (* a y) x) (/ (* y (- z b)) x)) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (* x z)) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* x (- (* -1 (* x z)) (* -1 (* a x)))) t))) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow x 2) (- (* -1 (* x z)) (* -1 (* a x)))) t)) (* -1 (* x (- (* -1 (* x z)) (* -1 (* a x)))))) t))) (* -1 (* a x))) t)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* x z) t)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* x z) (* y (- (+ a z) b))) t)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* y (- z b)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* x z) (* y (- z b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y (- z b))))))
#s(approx (- (+ a z) b) #s(hole binary64 (- z b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (/ (* y (- z b)) (* a x)))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* a (+ (/ t (+ t x)) (/ (* x z) (* a (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a (+ t (/ (* x z) a)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a (+ t (+ y (+ (/ (* x z) a) (/ (* y (- z b)) a)))))))
#s(approx (- (+ a z) b) #s(hole binary64 a))
#s(approx (- (+ a z) b) #s(hole binary64 (* a (- (+ 1 (/ z a)) (/ b a)))))
#s(approx (+ a z) #s(hole binary64 (* a (+ 1 (/ z a)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (/ (* y (- z b)) x) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t (+ t x))) (* -1 (/ (* x z) (* a (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 (/ (* x z) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* a (+ (* -1 t) (+ (* -1 y) (* -1 (/ (+ (* x z) (* y (- z b))) a))))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* a (- (* -1 (/ (- z b) a)) 1)))))
#s(approx (+ a z) #s(hole binary64 (* -1 (* a (- (* -1 (/ z a)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a t) (+ (* x z) (* y (+ a z)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (+ a z)))
#s(approx (- (+ a z) b) #s(hole binary64 (+ a (+ z (* -1 b)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x)))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* b (+ (* -1 y) (+ (/ (* a t) b) (+ (/ (* x z) b) (/ (* y (+ a z)) b)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 b)))
#s(approx (- (+ a z) b) #s(hole binary64 (* b (- (+ (/ a b) (/ z b)) 1))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ (/ (* a (+ t y)) x) (/ (* y z) x)) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (+ (* a t) (+ (* x z) (* y (+ a z)))) b)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ (+ a z) b)))))))
Calls

18 calls:

TimeVariablePointExpression
57.0ms
z
@0
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (* (/ (neg t) x) z) (/ (neg t) x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (- (+ a z) b) (+ a z) (+ (+ x t) y) (+ x t))
55.0ms
t
@inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (* (/ (neg t) x) z) (/ (neg t) x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (- (+ a z) b) (+ a z) (+ (+ x t) y) (+ x t))
8.0ms
x
@0
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (* (/ (neg t) x) z) (/ (neg t) x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (- (+ a z) b) (+ a z) (+ (+ x t) y) (+ x t))
7.0ms
x
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (* (/ (neg t) x) z) (/ (neg t) x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (- (+ a z) b) (+ a z) (+ (+ x t) y) (+ x t))
5.0ms
z
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (* (/ (neg t) x) z) (/ (neg t) x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (- (+ a z) b) (+ a z) (+ (+ x t) y) (+ x t))

rewrite759.0ms (5.1%)

Memory
5.6MiB live, 609.9MiB allocated; 168ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0275122946
0279321508
0880519893
02889119230
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
548 → 639
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(neg.f64 b)
b
(/.f64 y (+.f64 (+.f64 t y) x))
y
(+.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
(+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z)
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z))
(*.f64 (/.f64 (neg.f64 t) x) z)
(/.f64 (neg.f64 t) x)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
(/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))
(fma.f64 a t (*.f64 z x))
(*.f64 z x)
(+.f64 t x)
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))
(fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))
(-.f64 (+.f64 a z) b)
(+.f64 a z)
(+.f64 (+.f64 x t) y)
(+.f64 x t)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (* (/ (neg t) x) z) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (neg t) x) #s(hole binary64 (* -1 (/ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (/ z t) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (/ a (pow t 2)) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (+ (* x (- (/ z (pow t 3)) (/ a (pow t 3)))) (/ a (pow t 2))) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a t)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (* z x) #s(hole binary64 (* x z)))
#s(approx (+ t x) #s(hole binary64 t))
#s(approx (+ t x) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* y z)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (+ (* x z) (* y z))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* y (- (+ a z) b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t y)))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ x t) #s(hole binary64 t))
#s(approx (+ x t) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* t (- (* a t) (* t z))) (pow x 2))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (/ (* a t) x) (/ (* (pow t 2) (- (* a t) (* t z))) (pow x 3)))) (+ (/ (* t z) x) (/ (* t (- (* a t) (* t z))) (pow x 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x z)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x (+ z (/ (* a t) x)))))
#s(approx (+ t x) #s(hole binary64 x))
#s(approx (+ t x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* x (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* b y) x)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* x z)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* x (+ z (+ (/ (* a t) x) (/ (* y (- (+ a z) b)) x))))))
#s(approx (+ (+ x t) y) #s(hole binary64 x))
#s(approx (+ (+ x t) y) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ x t) #s(hole binary64 x))
#s(approx (+ x t) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* a t)) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (* t (- (* -1 (* a t)) (* -1 (* t z)))) x))) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (- (* -1 (/ (* (pow t 2) (- (* -1 (* a t)) (* -1 (* t z)))) x)) (* -1 (* t (- (* -1 (* a t)) (* -1 (* t z)))))) x))) (* -1 (* t z))) x)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* a t) x)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) x)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (+ (* a t) (* y (- (+ a z) b))) x)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* a t) (* t z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x)) (/ (* t z) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (- (+ a z) b))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* y (- a b)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* y (- (+ (/ a x) (/ (* a t) (* x y))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* y (- (+ a z) b))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* y (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) b))))
#s(approx (+ (+ x t) y) #s(hole binary64 y))
#s(approx (+ (+ x t) y) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* y (- (+ (* -1 a) (* -1 (- z b))) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (/ (* a t) x) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (* -1 z)) (* -1 b))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* y (- (+ (* -1 a) (+ (* -1 z) (* -1 (/ (+ (* a t) (* x z)) y)))) (* -1 b))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* y (+ (* -1 (- (+ a z) b)) (* -1 (/ (+ (* a t) (* x z)) y)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (+ (* -1 (* b y)) (* a (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* t z) x)) (/ (* a (+ t y)) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* a t) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* a (+ t y)) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a (+ t y)) (* z (+ x y))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (* y (- a b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* y (- a b)) (* z (+ x y))))))
#s(approx (- (+ a z) b) #s(hole binary64 (- a b)))
#s(approx (- (+ a z) b) #s(hole binary64 (- (+ a z) b)))
#s(approx (+ a z) #s(hole binary64 a))
#s(approx (+ a z) #s(hole binary64 (+ a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* z (+ (/ x (+ t x)) (/ (* a t) (* z (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* z (+ x (/ (* a t) z)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (+ x y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* z (- (+ x (+ y (/ (* a (+ t y)) z))) (/ (* b y) z)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* z (+ x y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* z (+ x (+ y (+ (/ (* a t) z) (/ (* y (- a b)) z)))))))
#s(approx (- (+ a z) b) #s(hole binary64 z))
#s(approx (- (+ a z) b) #s(hole binary64 (* z (- (+ 1 (/ a z)) (/ b z)))))
#s(approx (+ a z) #s(hole binary64 z))
#s(approx (+ a z) #s(hole binary64 (* z (+ 1 (/ a z)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* z (- (* -1 y) (* -1 (+ t y)))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (* -1 (/ (+ t y) x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ x (+ t x))) (* -1 (/ (* a t) (* z (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 (/ (* a t) z)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* z (+ (* -1 (+ x y)) (* -1 (/ (- (* a (+ t y)) (* b y)) z)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* z (+ (* -1 x) (+ (* -1 y) (* -1 (/ (+ (* a t) (* y (- a b))) z))))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* z (- (* -1 (/ (- a b) z)) 1)))))
#s(approx (+ a z) #s(hole binary64 (* -1 (* z (- (* -1 (/ a z)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a y) (* y (- z b))) (* y z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (/ a x) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (/ z (pow x 2)) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (+ (* t (- (/ a (pow x 3)) (/ z (pow x 3)))) (/ z (pow x 2))) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a y) (* z (+ x y))) (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (+ (* a t) (+ (* a y) (* z (+ x y)))) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* x z) (* y (- (+ a z) b)))))
#s(approx (+ (+ x t) y) #s(hole binary64 (+ x y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x)))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (/ (* x z) t)) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* x (- (* x z) (* a x))) (pow t 2))) (/ (* x z) t))) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (/ (* x z) t) (/ (* (pow x 2) (- (* x z) (* a x))) (pow t 3)))) (+ (/ (* a x) t) (/ (* x (- (* x z) (* a x))) (pow t 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* t (+ a (/ (* x z) t)))))
#s(approx (+ t x) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* t (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (/ (* b y) t)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a t)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* t (+ a (+ (/ (* x z) t) (/ (* y (- (+ a z) b)) t))))))
#s(approx (+ (+ x t) y) #s(hole binary64 t))
#s(approx (+ (+ x t) y) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (+ x t) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* t (- (* -1 a) (* -1 z))) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ (/ (* a y) x) (/ (* y (- z b)) x)) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (* x z)) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* x (- (* -1 (* x z)) (* -1 (* a x)))) t))) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow x 2) (- (* -1 (* x z)) (* -1 (* a x)))) t)) (* -1 (* x (- (* -1 (* x z)) (* -1 (* a x)))))) t))) (* -1 (* a x))) t)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* x z) t)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) t)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (+ (* x z) (* y (- (+ a z) b))) t)))))))
#s(approx (+ (+ x t) y) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (+ x t) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (* y (- z b)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (- (* z (+ x y)) (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* x z) (* y (- z b)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a (+ t y)) (+ (* x z) (* y (- z b))))))
#s(approx (- (+ a z) b) #s(hole binary64 (- z b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (/ (* y (- z b)) (* a x)))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* a (+ (/ t (+ t x)) (/ (* x z) (* a (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a (+ t (/ (* x z) a)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (+ t y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* a (- (+ t (+ y (/ (* z (+ x y)) a))) (/ (* b y) a)))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a (+ t y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* a (+ t (+ y (+ (/ (* x z) a) (/ (* y (- z b)) a)))))))
#s(approx (- (+ a z) b) #s(hole binary64 a))
#s(approx (- (+ a z) b) #s(hole binary64 (* a (- (+ 1 (/ z a)) (/ b a)))))
#s(approx (+ a z) #s(hole binary64 (* a (+ 1 (/ z a)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (/ (* y (- z b)) x) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t (+ t x))) (* -1 (/ (* x z) (* a (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 (/ (* x z) a)))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* a (+ (* -1 (+ t y)) (* -1 (/ (- (* z (+ x y)) (* b y)) a)))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* a (+ (* -1 t) (+ (* -1 y) (* -1 (/ (+ (* x z) (* y (- z b))) a))))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* a (- (* -1 (/ (- z b) a)) 1)))))
#s(approx (+ a z) #s(hole binary64 (* -1 (* a (- (* -1 (/ z a)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* z (+ t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (- (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* a (+ t y)) (* z (+ x y)))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a (+ t y)) (* z (+ x y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* a t) (+ (* x z) (* y (+ a z))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (+ (* -1 (* b y)) (+ (* a t) (+ (* x z) (* y (+ a z)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (+ a z)))
#s(approx (- (+ a z) b) #s(hole binary64 (+ a (+ z (* -1 b)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x)))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* b (- (+ (/ (* a (+ t y)) b) (/ (* z (+ x y)) b)) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* b y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* b (+ (* -1 y) (+ (/ (* a t) b) (+ (/ (* x z) b) (/ (* y (+ a z)) b)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 b)))
#s(approx (- (+ a z) b) #s(hole binary64 (* b (- (+ (/ a b) (/ z b)) 1))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ (/ (* a (+ t y)) x) (/ (* y z) x)) (/ (* z (+ t y)) x)) b)) (/ y x))))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (+ (* a (+ t y)) (* z (+ x y))) b)) (* -1 y))))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) #s(hole binary64 (* -1 (* b (+ y (* -1 (/ (+ (* a t) (+ (* x z) (* y (+ a z)))) b)))))))
#s(approx (- (+ a z) b) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ (+ a z) b)))))))
Outputs
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) (+.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))) a)))
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) (-.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (+.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))) a)))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (-.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) (+.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))) a)))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) (-.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)))
(-.f64 (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (+.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))) a)))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) (-.f64 #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)))
(+.f64 (fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))) a))
(fma.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(fma.f64 b (neg.f64 (/.f64 y (+.f64 (+.f64 t y) x))) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(+.f64 (*.f64 (/.f64 y (+.f64 (+.f64 t y) x)) (neg.f64 b)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z))
(*.f64 #s(literal -1 binary64) b)
(*.f64 b #s(literal -1 binary64))
(neg.f64 b)
b
(/.f64 (neg.f64 y) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 y (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 y (neg.f64 (+.f64 (+.f64 t y) x))))
(neg.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t y) x)))
y
(fma.f64 #s(literal 1 binary64) (+.f64 t y) x)
(+.f64 (+.f64 t y) x)
(+.f64 t (+.f64 y x))
(*.f64 #s(literal 1 binary64) (+.f64 t y))
(+.f64 t y)
t
x
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(*.f64 a (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (-.f64 (neg.f64 t) y) (neg.f64 a)) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x))
(/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 y))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 (+.f64 (+.f64 t y) x))))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 (-.f64 (neg.f64 t) y) (neg.f64 (+.f64 (+.f64 t y) x))))
(-.f64 (/.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (/.f64 y (+.f64 (+.f64 t y) x)))
(*.f64 #s(literal -1 binary64) (+.f64 t y))
(*.f64 (+.f64 t y) #s(literal -1 binary64))
(neg.f64 (+.f64 t y))
(fma.f64 #s(literal -1 binary64) t (neg.f64 y))
(fma.f64 t #s(literal -1 binary64) (neg.f64 y))
(-.f64 (neg.f64 t) y)
(+.f64 (neg.f64 t) (neg.f64 y))
(*.f64 #s(literal -1 binary64) t)
(*.f64 t #s(literal -1 binary64))
(neg.f64 t)
a
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
(+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z)
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z))
(*.f64 (/.f64 (neg.f64 t) x) z)
(*.f64 (/.f64 (*.f64 z t) x) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 z t) x))
(*.f64 (neg.f64 t) (/.f64 z x))
(*.f64 z (/.f64 (neg.f64 t) x))
(*.f64 t (/.f64 (neg.f64 z) x))
(/.f64 (*.f64 (*.f64 (neg.f64 z) t) #s(literal -1 binary64)) (neg.f64 x))
(/.f64 (neg.f64 (*.f64 (neg.f64 z) t)) (neg.f64 x))
(/.f64 (*.f64 (neg.f64 z) t) (neg.f64 (neg.f64 x)))
(/.f64 (*.f64 (neg.f64 z) t) x)
(/.f64 (*.f64 z t) (neg.f64 x))
(neg.f64 (*.f64 z (/.f64 t x)))
(neg.f64 (*.f64 (/.f64 t x) z))
(neg.f64 (/.f64 (*.f64 z t) x))
(*.f64 (/.f64 t x) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 t x))
(/.f64 (neg.f64 t) (neg.f64 (neg.f64 x)))
(/.f64 (neg.f64 t) x)
(/.f64 t (neg.f64 x))
(neg.f64 (/.f64 t x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
(*.f64 (/.f64 (fma.f64 a t (*.f64 z x)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (+.f64 t x)))
(*.f64 (/.f64 #s(literal -1 binary64) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
(/.f64 (fma.f64 (*.f64 (neg.f64 a) t) (neg.f64 (+.f64 t x)) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 (neg.f64 x) z))) (*.f64 (+.f64 t x) (+.f64 t x)))
(/.f64 (fma.f64 (*.f64 (neg.f64 a) t) (+.f64 t x) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z x))) (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))))
(/.f64 (fma.f64 (*.f64 a t) (neg.f64 (+.f64 t x)) (*.f64 (+.f64 t x) (*.f64 (neg.f64 x) z))) (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))))
(/.f64 (fma.f64 (*.f64 a t) (+.f64 t x) (*.f64 (+.f64 t x) (*.f64 z x))) (*.f64 (+.f64 t x) (+.f64 t x)))
(/.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (neg.f64 (+.f64 t x)))
(/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))
(neg.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (neg.f64 (+.f64 t x))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (+.f64 t x)))
(fma.f64 (/.f64 (*.f64 a t) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (+.f64 t x)) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 t (+.f64 t x)) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 (/.f64 (neg.f64 a) (+.f64 t x)) (/.f64 t #s(literal -1 binary64)) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 (/.f64 #s(literal -1 binary64) (+.f64 t x)) (/.f64 (*.f64 a t) #s(literal -1 binary64)) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 (/.f64 t (+.f64 t x)) a (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 (*.f64 (/.f64 t (+.f64 t x)) a) #s(literal 1 binary64) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 #s(literal 1 binary64) (*.f64 (/.f64 t (+.f64 t x)) a) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 a (/.f64 t (+.f64 t x)) (*.f64 (/.f64 x (+.f64 t x)) z))
(-.f64 (*.f64 (/.f64 t (+.f64 t x)) a) (*.f64 (/.f64 (neg.f64 x) (+.f64 t x)) z))
(+.f64 (/.f64 (*.f64 (*.f64 a t) (+.f64 t x)) (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 (+.f64 t x) (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))
(+.f64 (*.f64 (/.f64 t (+.f64 t x)) a) (*.f64 (/.f64 x (+.f64 t x)) z))
(fma.f64 a t (*.f64 z x))
(fma.f64 t a (*.f64 z x))
(-.f64 (*.f64 a t) (*.f64 (neg.f64 x) z))
(+.f64 (*.f64 a t) (*.f64 z x))
(*.f64 z x)
(*.f64 x z)
(*.f64 #s(literal 1 binary64) (+.f64 t x))
(+.f64 t x)
(/.f64 (neg.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))) (neg.f64 (+.f64 (+.f64 x t) y)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
(neg.f64 (/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (neg.f64 (+.f64 (+.f64 x t) y))))
(neg.f64 (/.f64 (neg.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))) (+.f64 (+.f64 x t) y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x))))
(fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))
(fma.f64 y (-.f64 (+.f64 a z) b) (fma.f64 a t (*.f64 z x)))
(-.f64 (fma.f64 (-.f64 (+.f64 a z) b) y (*.f64 a t)) (*.f64 (neg.f64 x) z))
(+.f64 (fma.f64 (-.f64 (+.f64 a z) b) y (*.f64 a t)) (*.f64 z x))
(+.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (fma.f64 a t (*.f64 z x)))
(-.f64 (+.f64 a z) b)
(+.f64 (+.f64 a z) (neg.f64 b))
(+.f64 a (-.f64 z b))
(+.f64 a z)
(+.f64 (+.f64 x t) y)
(+.f64 x (+.f64 t y))
(+.f64 x t)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (+.f64 t y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 x (fma.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (-.f64 (-.f64 (fma.f64 (fma.f64 b (/.f64 y (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y)))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 t y) (+.f64 t y)))))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y))))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (+.f64 t y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 x (fma.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (fma.f64 x (-.f64 (fma.f64 b (/.f64 y (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y)))) (fma.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (pow.f64 (+.f64 t y) #s(literal 4 binary64)))) x (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 x y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) x (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 x (-.f64 (*.f64 (fma.f64 (neg.f64 x) (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 y (+.f64 t y))))
#s(approx (+ (+ t y) x) (+.f64 t y))
#s(approx (+ (+ t y) x) (+.f64 t (+.f64 x y)))
#s(approx x x)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 y (/.f64 z (+.f64 t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 x (fma.f64 (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 x (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))))) (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 a (+.f64 #s(literal -1 binary64) (/.f64 x (+.f64 t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (/.f64 a (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (+.f64 (/.f64 a (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y))) (/.f64 (*.f64 a x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(literal -1 binary64))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (/.f64 x (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y))) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (*.f64 (-.f64 (/.f64 x (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) x) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (+.f64 t y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (*.f64 y (/.f64 z (+.f64 t y))) (*.f64 b (/.f64 y (+.f64 t y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 z (+.f64 t y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (fma.f64 a (+.f64 t y) (fma.f64 z x (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))
#s(approx (* (/ (neg t) x) z) (*.f64 (/.f64 (neg.f64 t) x) z))
#s(approx (/ (neg t) x) (/.f64 (neg.f64 t) x))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) a)
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 (-.f64 z a) x) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (fma.f64 (/.f64 (-.f64 z a) (*.f64 (*.f64 t t) t)) x (/.f64 (-.f64 a z) (*.f64 t t))) x (/.f64 (-.f64 z a) t)) x)))
#s(approx (+ (* a t) (* z x)) (*.f64 a t))
#s(approx (+ (* a t) (* z x)) (fma.f64 a t (*.f64 z x)))
#s(approx (* z x) (*.f64 z x))
#s(approx (+ t x) t)
#s(approx (+ t x) (+.f64 t x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (+ (+ x t) y) (+.f64 t y))
#s(approx (+ (+ x t) y) (+.f64 t (+.f64 x y)))
#s(approx (+ x t) t)
#s(approx (+ x t) (+.f64 t x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) z)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) x) (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 z (+.f64 t y))) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x)))) (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (fma.f64 (/.f64 (-.f64 (neg.f64 t) y) x) a (+.f64 (/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) a (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) (*.f64 (*.f64 x x) x)) (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)) (fma.f64 (*.f64 z (+.f64 t y)) (*.f64 x x) (*.f64 x (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y))))) (*.f64 (*.f64 x x) x))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 t y) y) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 t y) x) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (/.f64 (*.f64 (+.f64 t y) y) x)))) x))
#s(approx (+ (+ t y) x) x)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (-.f64 (neg.f64 t) y) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 x x)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 (+.f64 z (fma.f64 y (/.f64 z x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) x) a))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (/.f64 (fma.f64 a (/.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (*.f64 a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) (*.f64 x x))))) (*.f64 a (+.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) y) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) (-.f64 y (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) (-.f64 y (/.f64 (+.f64 (/.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) (-.f64 y (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))))) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (-.f64 (neg.f64 t) y) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (*.f64 x x)) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z y)) x)) (/.f64 (*.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x))) (/.f64 (fma.f64 y b (*.f64 z (+.f64 t y))) x)) (/.f64 (*.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (+.f64 t y)) (*.f64 x x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) z)
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (fma.f64 (neg.f64 t) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x x)) (*.f64 (/.f64 (-.f64 a z) x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 (+.f64 z (fma.f64 (/.f64 t x) a (/.f64 (*.f64 (*.f64 (-.f64 a z) t) (*.f64 t t)) (*.f64 (*.f64 x x) x)))) (*.f64 t (+.f64 (/.f64 z x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x x))))))
#s(approx (+ (* a t) (* z x)) (*.f64 z x))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 z (*.f64 (/.f64 t x) a)) x))
#s(approx (+ t x) x)
#s(approx (+ t x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) x)) x))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 z x))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) x)) x))
#s(approx (+ (+ x t) y) x)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (+ x t) x)
#s(approx (+ x t) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a))) x))) (*.f64 y b)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (fma.f64 (neg.f64 y) z (-.f64 (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (-.f64 (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) a))) x) (neg.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a))))) x) (*.f64 y b)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a)))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (-.f64 (neg.f64 t) y) (*.f64 z (-.f64 (-.f64 y t) y)))) x))) (fma.f64 y b (*.f64 z (+.f64 t y)))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (fma.f64 (neg.f64 y) z (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) x) (neg.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (-.f64 (neg.f64 t) y) (*.f64 z (-.f64 (-.f64 y t) y)))))) x) (fma.f64 y b (*.f64 z (+.f64 t y))))) x)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 t y) y) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y)))) (neg.f64 x)) (*.f64 (+.f64 t y) y)) x)) (neg.f64 x)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (-.f64 (neg.f64 t) y) x) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 y) z (fma.f64 (+.f64 t y) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 z (+.f64 t y)))) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 (-.f64 (neg.f64 t) y) (*.f64 z (-.f64 (-.f64 y t) y)))) x))) (*.f64 z (+.f64 t y))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (*.f64 (-.f64 (neg.f64 t) y) a)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x) (*.f64 (-.f64 (neg.f64 t) y) a)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (*.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) a)) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x) (*.f64 (-.f64 (neg.f64 t) y) a)) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) (-.f64 y (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 t) (-.f64 y (/.f64 (+.f64 (/.f64 (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (*.f64 (-.f64 (neg.f64 t) y) (*.f64 (+.f64 t y) (+.f64 t y)))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y))) (fma.f64 (+.f64 t y) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x) (*.f64 z (+.f64 t y)))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (fma.f64 (-.f64 z b) y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x) (*.f64 (-.f64 (neg.f64 t) y) (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))))) x)))) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 z (/.f64 (+.f64 (neg.f64 (*.f64 t (+.f64 a (/.f64 (*.f64 (-.f64 a z) (neg.f64 t)) x)))) (*.f64 z t)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a t (/.f64 (fma.f64 (*.f64 t t) (*.f64 (/.f64 (-.f64 a z) x) t) (*.f64 (*.f64 (-.f64 a z) (neg.f64 t)) t)) x))) (*.f64 z t)) x)))
#s(approx (+ (* a t) (* z x)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (*.f64 (/.f64 t x) a))))
#s(approx (+ t x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 t) x) #s(literal 1 binary64))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) x))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) x))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 x) (-.f64 (/.f64 (-.f64 (neg.f64 t) y) x) #s(literal 1 binary64))))
#s(approx (+ x t) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 t) x) #s(literal 1 binary64))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 y (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x))))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 y (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t x)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (/.f64 (neg.f64 y) (*.f64 (+.f64 t x) (+.f64 t x))) y (/.f64 y (+.f64 t x))))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 y) (pow.f64 (+.f64 t x) #s(literal 4 binary64))) y (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx y y)
#s(approx (+ (+ t y) x) (+.f64 t x))
#s(approx (+ t y) t)
#s(approx (+ t y) (+.f64 t y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 y (fma.f64 (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 y (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (neg.f64 a) (/.f64 t (+.f64 t x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 t (+.f64 t x)) a))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (/.f64 (neg.f64 t) (+.f64 t x)) a (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (/.f64 (neg.f64 t) (+.f64 t x)) a (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) y)) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (neg.f64 t) (+.f64 t x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 t (+.f64 t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y)) y)))
#s(approx (- (neg t) y) (neg.f64 t))
#s(approx (- (neg t) y) (-.f64 (neg.f64 y) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 y (+.f64 (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x)))) (-.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (-.f64 a b) y (*.f64 (-.f64 a z) t)) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (-.f64 a z) x) t))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (-.f64 a b) y (*.f64 (-.f64 a z) t)) x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a t (*.f64 z x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a t (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 z x)))
#s(approx (+ (+ x t) y) (+.f64 t x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 z (-.f64 b (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 x (+.f64 t x))))) (*.f64 y y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (neg.f64 a)) (/.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 x (+.f64 t x)))))) (*.f64 (*.f64 y y) y))) (+.f64 (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 x (+.f64 t x))))) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 b (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 t x) y)) (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 x (+.f64 t x))) (+.f64 t x)) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 z (-.f64 x (+.f64 t x))) (fma.f64 (*.f64 (+.f64 t x) z) (*.f64 y y) (*.f64 y (*.f64 (*.f64 z (-.f64 x (+.f64 t x))) (+.f64 t x))))) (*.f64 (*.f64 y y) y))))
#s(approx (/ y (+ (+ t y) x)) #s(literal 1 binary64))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)))
#s(approx (/ y (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y (+.f64 t x))) (*.f64 y y))))
#s(approx (/ y (+ (+ t y) x)) (-.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (+ (+ t y) x) y)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)) y))
#s(approx (+ t y) y)
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t y)) y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) (*.f64 y y)) (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 x (/.f64 z y) (-.f64 (/.f64 (*.f64 (*.f64 z (-.f64 x (+.f64 t x))) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y)) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 x (+.f64 t x))) (+.f64 t x)) (*.f64 y y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (*.f64 (*.f64 y y) y)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x y) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (/.f64 x y) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (+.f64 (/.f64 x y) (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) x) (*.f64 (*.f64 y y) y))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (neg.f64 y))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a z) (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y)) (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (+.f64 a z) (-.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) (/.f64 (*.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y))) b)) (*.f64 (+.f64 t x) (+.f64 (/.f64 (-.f64 (+.f64 a z) b) y) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (-.f64 (/.f64 (+.f64 z (*.f64 (/.f64 t x) a)) y) (/.f64 b x))) (*.f64 t (/.f64 z (*.f64 x y)))) y))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 a b) y) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (+.f64 (/.f64 a x) (-.f64 (*.f64 a (/.f64 t (*.f64 x y))) (/.f64 b x))) (*.f64 t (/.f64 z (*.f64 x y)))) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) y))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (+.f64 a z) b) y))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) y))
#s(approx (+ (+ x t) y) y)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)) y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (fma.f64 (neg.f64 x) z (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (*.f64 (neg.f64 (+.f64 t x)) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 x (+.f64 t x)))))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x) (/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 x (+.f64 t x)))))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y))) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 x (+.f64 t x))))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (*.f64 (neg.f64 x) z) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (fma.f64 (neg.f64 x) z (-.f64 (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (neg.f64 (*.f64 z (-.f64 x (+.f64 t x)))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b))))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (neg.f64 (*.f64 z (-.f64 x (+.f64 t x)))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 x (+.f64 t x))))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) y) (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x)))) y) (+.f64 t x)) y)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 t x) (neg.f64 y)) #s(literal 1 binary64))))
#s(approx (+ t y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 x) z (fma.f64 (+.f64 t x) (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y) (*.f64 (+.f64 t x) z))) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 z (-.f64 x (+.f64 t x))) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 x (+.f64 t x))))) y))) (*.f64 (+.f64 t x) z)) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 a (-.f64 (-.f64 t t) x)))) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 t x) y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) (neg.f64 y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (neg.f64 y) (+.f64 #s(literal 1 binary64) (/.f64 t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (fma.f64 (+.f64 t x) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x)))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (fma.f64 z x (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (*.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) (+.f64 t x))) y)))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 (neg.f64 a) (-.f64 (-.f64 z b) z)) y) (neg.f64 x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (+.f64 z (*.f64 (/.f64 (-.f64 a z) x) t)) y)) (/.f64 z x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 (-.f64 (neg.f64 a) (-.f64 (-.f64 z b) z)) y) (neg.f64 x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) (+.f64 (-.f64 (-.f64 (neg.f64 a) z) (/.f64 (fma.f64 a t (*.f64 z x)) y)) b)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (neg.f64 y) (-.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (/.f64 (fma.f64 a t (*.f64 z x)) y))))
#s(approx (+ (+ x t) y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 t x) (neg.f64 y)) #s(literal 1 binary64))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx z z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 y b)) (+.f64 t (+.f64 x y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z (/.f64 (*.f64 a (+.f64 t y)) x))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (neg.f64 z) t (*.f64 a (+.f64 t y))) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (fma.f64 (-.f64 a b) y (*.f64 (+.f64 x y) z))))
#s(approx (- (+ a z) b) (-.f64 a b))
#s(approx (- (+ a z) b) (-.f64 (+.f64 a z) b))
#s(approx (+ a z) a)
#s(approx (+ a z) (+.f64 a z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 a (+.f64 t y)) z))) (+.f64 t (+.f64 x y)))) z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y)))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (*.f64 z x))) (/.f64 t x)) z))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (neg.f64 t) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (*.f64 z x))) z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 x (/.f64 (*.f64 a t) z)) (+.f64 t x)) z))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 x (/.f64 (*.f64 a t) z)) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 x y) z))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 x (+.f64 y (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) z))) z))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 x y) z))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 x (+.f64 y (/.f64 (fma.f64 a t (*.f64 (-.f64 a b) y)) z))) z))
#s(approx (- (+ a z) b) z)
#s(approx (- (+ a z) b) (+.f64 z (*.f64 z (/.f64 (-.f64 a b) z))))
#s(approx (+ a z) z)
#s(approx (+ a z) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (-.f64 (neg.f64 x) y) (+.f64 t (+.f64 x y))) (/.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (+.f64 t (+.f64 x y))) z))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 t (+.f64 x y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 z) (/.f64 (+.f64 (-.f64 (neg.f64 x) y) (/.f64 (*.f64 y b) z)) (+.f64 t (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (-.f64 (neg.f64 x) y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (-.f64 (/.f64 (neg.f64 y) x) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 z) (-.f64 (-.f64 (/.f64 (neg.f64 y) x) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (*.f64 z x))) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 y) x) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 a (+.f64 t y))) (*.f64 z x)) (/.f64 (+.f64 t y) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (neg.f64 z) (neg.f64 (/.f64 (+.f64 x (/.f64 (*.f64 a t) z)) (+.f64 t x)))))
#s(approx (+ (* a t) (* z x)) (*.f64 (neg.f64 z) (-.f64 (neg.f64 x) (/.f64 (*.f64 a t) z))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 (-.f64 (-.f64 (neg.f64 x) y) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) z))) z))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (neg.f64 x) y) (neg.f64 z)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (neg.f64 z) (-.f64 (-.f64 (neg.f64 x) y) (/.f64 (fma.f64 a t (*.f64 (-.f64 a b) y)) z))))
#s(approx (- (+ a z) b) (*.f64 (neg.f64 z) (-.f64 (/.f64 (-.f64 a b) (neg.f64 z)) #s(literal 1 binary64))))
#s(approx (+ a z) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 a) z) #s(literal 1 binary64))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 (neg.f64 y) b) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (-.f64 (neg.f64 x) y) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))))) t (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 b (/.f64 y (*.f64 (-.f64 (neg.f64 x) y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (-.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t)) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))))) t (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (-.f64 (fma.f64 (fma.f64 b (/.f64 y (*.f64 (-.f64 (neg.f64 x) y) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (fma.f64 t (fma.f64 b (/.f64 y (*.f64 (-.f64 (neg.f64 x) y) (*.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))) (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y)))) t))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 x y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 t y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 t (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 y (+.f64 x y))))
#s(approx (+ (+ t y) x) (+.f64 x y))
#s(approx t t)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (*.f64 t (/.f64 z (+.f64 x y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t) (/.f64 z (+.f64 x y))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (*.f64 a y) (-.f64 (neg.f64 x) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 a (/.f64 y (-.f64 (neg.f64 x) y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 a (/.f64 y (-.f64 (neg.f64 x) y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))))) t)) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 y (-.f64 (neg.f64 x) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 y (-.f64 (neg.f64 x) y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 y (-.f64 (neg.f64 x) y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) t (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y))))) t)) t)))
#s(approx (- (neg t) y) (-.f64 (neg.f64 t) y))
#s(approx (neg t) (neg.f64 t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 x y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (*.f64 a (/.f64 y (+.f64 x y))) (*.f64 b (/.f64 y (+.f64 x y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 a (+.f64 x y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (-.f64 a z) t (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z)))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (-.f64 a z) t (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z)))) x))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (fma.f64 (/.f64 (-.f64 z a) (*.f64 x x)) t (/.f64 (-.f64 a z) x)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (fma.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 (*.f64 x x) x)) t (/.f64 (-.f64 z a) (*.f64 x x))) t (/.f64 (-.f64 a z) x)) t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y)))
#s(approx (+ (+ x t) y) (+.f64 x y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) a)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (fma.f64 b (/.f64 (*.f64 (+.f64 x y) y) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) z) t))) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (/.f64 (fma.f64 (*.f64 (*.f64 (-.f64 (neg.f64 x) y) (+.f64 x y)) y) b (fma.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t (*.f64 (*.f64 t t) (*.f64 (+.f64 x y) z)))) (*.f64 (*.f64 t t) t))) (neg.f64 a)) (/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) (*.f64 (+.f64 x y) (+.f64 x y))) z (*.f64 (*.f64 (-.f64 (neg.f64 x) y) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)))) (*.f64 (*.f64 t t) t))) (+.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (neg.f64 t)) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (fma.f64 (+.f64 x y) z (/.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t))) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (fma.f64 (+.f64 x y) z (*.f64 b (fma.f64 y (/.f64 (+.f64 x y) t) (*.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64))))))) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (*.f64 z (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t)))))) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) y) t)))) t))
#s(approx (+ (+ t y) x) t)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x y) t)) t))
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 z) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (*.f64 (+.f64 x y) z)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (/.f64 (*.f64 z (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y)))) t)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (-.f64 (fma.f64 (neg.f64 z) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t)) (*.f64 (+.f64 x y) z)) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t))) t))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (*.f64 (*.f64 t t) t)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x t) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (/.f64 x t) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (+.f64 (/.f64 x t) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) x) (*.f64 (*.f64 t t) t))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (neg.f64 x) y) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 t t)) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a (/.f64 (fma.f64 a y (*.f64 (+.f64 x y) z)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (*.f64 t t) t))) (/.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (+.f64 x y)) (*.f64 t t))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (/.f64 (+.f64 z (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) x)) t)) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) (/.f64 z x))) t))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (-.f64 a z) x) t))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (+.f64 (/.f64 a x) (/.f64 (*.f64 (-.f64 (+.f64 a z) b) y) (*.f64 x t))) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) (/.f64 z x))) t))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 x (-.f64 z a)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (fma.f64 (neg.f64 x) (/.f64 (*.f64 x (-.f64 z a)) (*.f64 t t)) (/.f64 (*.f64 x (-.f64 z a)) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 (+.f64 a (fma.f64 x (/.f64 z t) (/.f64 (*.f64 (*.f64 x (-.f64 z a)) (*.f64 x x)) (*.f64 (*.f64 t t) t)))) (fma.f64 a (/.f64 x t) (*.f64 x (/.f64 (*.f64 x (-.f64 z a)) (*.f64 t t))))))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 a (*.f64 x (/.f64 z t))) t))
#s(approx (+ t x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x t)) t))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 a (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) t)) t))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 a t))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 a (/.f64 (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y)) t)) t))
#s(approx (+ (+ x t) y) t)
#s(approx (+ (+ x t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x y) t)) t))
#s(approx (+ x t) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x t)) t))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b)) (*.f64 a y)) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) (*.f64 a (-.f64 (-.f64 y x) y)) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (fma.f64 (+.f64 x y) a (*.f64 y b))) (*.f64 a y)) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y) (/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)) (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z))) t))) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (fma.f64 (+.f64 x y) a (*.f64 y b))) (*.f64 a y)) t) a)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) z (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) z (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)) t) (neg.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)))) t) (*.f64 y b))) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) y) b) (*.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) z)) t) (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)))) t) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 t)) (*.f64 (+.f64 x y) y)) t)) (neg.f64 t)))
#s(approx (+ (+ t y) x) (*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 x) y) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ t y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) z (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (/.f64 (*.f64 z (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y)))) t)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 (-.f64 (neg.f64 x) y)) z (/.f64 (-.f64 (/.f64 (*.f64 z (-.f64 (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (neg.f64 t)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t)) t))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (-.f64 (neg.f64 x) y) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 (-.f64 (neg.f64 x) y) (*.f64 a (-.f64 (-.f64 y x) y)))) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 x y) t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) (neg.f64 t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) (neg.f64 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (*.f64 (+.f64 x y) (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t)) (*.f64 (+.f64 x y) a))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (/.f64 (fma.f64 (*.f64 (-.f64 (neg.f64 x) y) (+.f64 x y)) (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t) (*.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) (+.f64 x y))) t) (*.f64 (+.f64 x y) a))) t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (neg.f64 a) x) (-.f64 (/.f64 (+.f64 z (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) x)) t) (/.f64 z x))) (neg.f64 t)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (-.f64 a z) x) t))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (/.f64 (neg.f64 a) x) (-.f64 (/.f64 (fma.f64 a y (*.f64 y (-.f64 (-.f64 z b) z))) (*.f64 x t)) (/.f64 z x))) (neg.f64 t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 x (-.f64 z a)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 a (/.f64 (+.f64 (neg.f64 (*.f64 x (+.f64 z (/.f64 (neg.f64 (*.f64 x (-.f64 z a))) t)))) (*.f64 a x)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 a (/.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (fma.f64 (*.f64 x x) (/.f64 (*.f64 x (-.f64 z a)) t) (*.f64 (neg.f64 x) (*.f64 x (-.f64 z a)))) t))) (*.f64 a x)) t)))
#s(approx (+ (* a t) (* z x)) (*.f64 (-.f64 (neg.f64 a) (*.f64 x (/.f64 z t))) (neg.f64 t)))
#s(approx (+ t x) (*.f64 (-.f64 (/.f64 x (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (neg.f64 a) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) t)) (neg.f64 t)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (neg.f64 a) (/.f64 (fma.f64 z x (*.f64 (-.f64 (+.f64 a z) b) y)) t)) (neg.f64 t)))
#s(approx (+ (+ x t) y) (*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 x) y) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ x t) (*.f64 (-.f64 (/.f64 x (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z))) (+.f64 t (+.f64 x y))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 t (+.f64 x y))) a))
#s(approx a a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 t (+.f64 x y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 (-.f64 z b) y)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 z x (*.f64 (-.f64 z b) y)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))))
#s(approx (- (+ a z) b) (-.f64 z b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) a)) (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y)))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t (+.f64 x y)) a))) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 a (+.f64 t y)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)) a)) a))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (*.f64 a (+.f64 t y)) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) (*.f64 a x))) a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 t (*.f64 x (/.f64 z a))) a))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a (+.f64 t y)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) a))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 a (+.f64 t y)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) a))
#s(approx (- (+ a z) b) a)
#s(approx (- (+ a z) b) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 z b) a)) a))
#s(approx (+ a z) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) a))) (/.f64 (+.f64 t y) (+.f64 t (+.f64 x y)))) (neg.f64 a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t (+.f64 x y)) a))) (neg.f64 a)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 a (+.f64 t y)) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 t) y) x) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)) a)) (neg.f64 a)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 t) y) x) (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) (*.f64 a x))) (neg.f64 a)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (neg.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x))) (neg.f64 a)))
#s(approx (+ (* a t) (* z x)) (*.f64 (-.f64 (neg.f64 t) (*.f64 x (/.f64 z a))) (neg.f64 a)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (-.f64 (neg.f64 t) y) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) (neg.f64 a)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (neg.f64 t) y) (neg.f64 a)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 (-.f64 (neg.f64 t) y) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) a)) (neg.f64 a)))
#s(approx (- (+ a z) b) (*.f64 (-.f64 (/.f64 (-.f64 z b) (neg.f64 a)) #s(literal 1 binary64)) (neg.f64 a)))
#s(approx (+ a z) (*.f64 (-.f64 (/.f64 z (neg.f64 a)) #s(literal 1 binary64)) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 t (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 t (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (neg b) (neg.f64 b))
#s(approx b b)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (+.f64 t (+.f64 x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 y (neg.f64 b) (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z))) (+.f64 t (+.f64 x y))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y)))) x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) x))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y)))) x))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 y (neg.f64 b) (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (fma.f64 z x (*.f64 (+.f64 a z) y))))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 y (neg.f64 b) (fma.f64 a t (fma.f64 z x (*.f64 (+.f64 a z) y)))))
#s(approx (- (+ a z) b) (+.f64 a z))
#s(approx (- (+ a z) b) (-.f64 (+.f64 a z) b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 (+.f64 t (+.f64 x y)) b))) b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (/.f64 (+.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) z) b)) (+.f64 t (+.f64 x y))) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 t (+.f64 x y))) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) b))) b))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (/.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) x)) b)) b))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 b) (/.f64 y x)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (/.f64 (neg.f64 y) x) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 x b))) b))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 y) b))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) b) y) b))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (neg.f64 y) b))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (+.f64 (neg.f64 y) (/.f64 (fma.f64 a t (fma.f64 z x (*.f64 (+.f64 a z) y))) b)) b))
#s(approx (- (+ a z) b) (neg.f64 b))
#s(approx (- (+ a z) b) (*.f64 (-.f64 (/.f64 (+.f64 a z) b) #s(literal 1 binary64)) b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 (+.f64 t (+.f64 x y)) b))) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 x y) (*.f64 (+.f64 t (+.f64 x y)) b)) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 t (+.f64 x y)) b))) (/.f64 y (+.f64 t (+.f64 x y)))) (neg.f64 b)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) x)) (neg.f64 b)) (/.f64 y x)) (neg.f64 b)))
#s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 x b))) (/.f64 y x)) (neg.f64 b)))
#s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 (-.f64 (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) b) y)) (neg.f64 b)))
#s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (*.f64 (-.f64 y (/.f64 (fma.f64 a t (fma.f64 z x (*.f64 (+.f64 a z) y))) b)) (neg.f64 b)))
#s(approx (- (+ a z) b) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 a z) b)) (neg.f64 b)))

eval260.0ms (1.7%)

Memory
-19.1MiB live, 167.4MiB allocated; 50ms collecting garbage
Compiler

Compiled 11 685 to 3 307 computations (71.7% saved)

prune175.0ms (1.2%)

Memory
14.2MiB live, 61.4MiB allocated; 3ms collecting garbage
Pruning

39 alts after pruning (36 fresh and 3 done)

PrunedKeptTotal
New58512597
Fresh92433
Picked325
Done011
Total59739636
Accuracy
100.0%
Counts
636 → 39
Alt Table
Click to see full alt table
StatusAccuracyProgram
11.9%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
27.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
7.8%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
8.4%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
8.6%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
42.1%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
67.7%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
▶77.5%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
33.0%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) t)) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) t)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) t)) a))
58.2%
(-.f64 (fma.f64 (neg.f64 b) #s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
▶63.3%
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
✓40.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
24.3%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
▶22.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
19.2%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
27.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
29.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
34.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x)))) z))
50.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
34.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
63.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
26.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
26.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
46.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
28.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
32.2%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
▶6.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
11.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
9.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
7.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
25.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
9.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
✓29.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
✓31.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
▶52.4%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
61.3%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) (+.f64 t (+.f64 x y)))) z))
Compiler

Compiled 2 026 to 1 877 computations (7.4% saved)

series247.0ms (1.7%)

Memory
28.7MiB live, 119.1MiB allocated; 9ms collecting garbage
Counts
41 → 499
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
(fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(neg.f64 b)
b
(/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
y
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)
(+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x))
#s(literal 1 binary64)
(/.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
(*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)
(/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(+.f64 y x)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)
(/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(-.f64 z (-.f64 b a))
(-.f64 b a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
(/.f64 (*.f64 (-.f64 a z) t) x)
(*.f64 (-.f64 a z) t)
(-.f64 a z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
(/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t))
(fma.f64 a t (*.f64 z x))
(*.f64 z x)
#s(approx (+ t x) t)
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(+.f64 (+.f64 t y) x)
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t y)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ (+ t y) x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ (+ t (+ x y)) x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ (+ t y) x)))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ 1 (+ t y)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (/ y (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ 1 (pow (+ t y) 3)) (/ y (pow (+ t y) 4)))) (/ y (pow (+ t y) 3))) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ y x) #s(hole binary64 y))
#s(approx (+ y x) #s(hole binary64 (+ x y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (/ z t) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (/ a (pow t 2)) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (+ (* x (- (/ z (pow t 3)) (/ a (pow t 3)))) (/ a (pow t 2))) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a t)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (* z x) #s(hole binary64 (* x z)))
#s(approx (+ t x) #s(hole binary64 t))
#s(approx (+ t x) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 1))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (+ (/ t x) (/ y x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t y)) (pow x 2))) (/ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t y) 2)) (pow x 3)))) (+ (* -1 (/ (* t (+ t y)) (pow x 2))) (/ t x)))))
#s(approx (+ y x) #s(hole binary64 x))
#s(approx (+ y x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* t (- (* a t) (* t z))) (pow x 2))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (/ (* a t) x) (/ (* (pow t 2) (- (* a t) (* t z))) (pow x 3)))) (+ (/ (* t z) x) (/ (* t (- (* a t) (* t z))) (pow x 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x z)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x (+ z (/ (* a t) x)))))
#s(approx (+ t x) #s(hole binary64 x))
#s(approx (+ t x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 y) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (* (+ t y) (- (* -1 y) (* -1 (+ t y)))) x))) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 y) (* -1 (+ t y)))) x)) (* -1 (* (+ t y) (- (* -1 y) (* -1 (+ t y)))))) x))) (* -1 (+ t y))) x)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* a t)) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (* t (- (* -1 (* a t)) (* -1 (* t z)))) x))) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (- (* -1 (/ (* (pow t 2) (- (* -1 (* a t)) (* -1 (* t z)))) x)) (* -1 (* t (- (* -1 (* a t)) (* -1 (* t z)))))) x))) (* -1 (* t z))) x)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* a t) x)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ y (* x (+ 1 (/ t x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (/ t x))))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ t x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (+ (/ t x) (/ y x))))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ x (+ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (/ 1 (+ t x)) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (/ x (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ 1 (pow (+ t x) 3)) (/ x (pow (+ t x) 4)))) (/ x (pow (+ t x) 3))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* y (+ 1 (/ (* x (+ 1 (/ t x))) y)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* y (+ (/ 1 x) (+ (/ 1 y) (/ t (* x y)))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ y x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (* y (+ (/ 1 x) (/ t (* x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t x)) (pow y 2))) (/ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t x) 2)) (pow y 3)))) (+ (* -1 (/ (* t (+ t x)) (pow y 2))) (/ t y)))))
#s(approx (+ y x) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (* x (+ 1 (/ t x))) y)) 1)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ 1 (/ t x)) y)) (/ 1 x))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ t (* x y))) (/ 1 x))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 x) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (* (+ t x) (- (* -1 x) (* -1 (+ t x)))) y))) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 x) (* -1 (+ t x)))) y)) (* -1 (* (+ t x) (- (* -1 x) (* -1 (+ t x)))))) y))) (* -1 (+ t x))) y)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (- z (- b a)) #s(hole binary64 (- a b)))
#s(approx (- z (- b a)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (/ (* a t) x)))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (+ (* -1 (/ (* t z) x)) (/ (* a t) x))))
#s(approx (* (- a z) t) #s(hole binary64 (* a t)))
#s(approx (* (- a z) t) #s(hole binary64 (+ (* -1 (* t z)) (* a t))))
#s(approx (- a z) #s(hole binary64 a))
#s(approx (- a z) #s(hole binary64 (+ a (* -1 z))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* a t) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 z))
#s(approx (- z (- b a)) #s(hole binary64 (* z (- (+ 1 (/ a z)) (/ b z)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (/ (* a t) (* x z))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- a z) t) #s(hole binary64 (* z (+ (* -1 t) (/ (* a t) z)))))
#s(approx (- a z) #s(hole binary64 (* -1 z)))
#s(approx (- a z) #s(hole binary64 (* z (- (/ a z) 1))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* z (+ (/ x (+ t x)) (/ (* a t) (* z (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* z (+ x (/ (* a t) z)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (- a b) z)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (* a t) (* x z))) (/ t x))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* z (+ t (* -1 (/ (* a t) z)))))))
#s(approx (- a z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ a z)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ x (+ t x))) (* -1 (/ (* a t) (* z (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 (/ (* a t) z)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t (* x (+ 1 (/ y x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (/ y x))))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t (+ x y))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (/ t (pow (+ x y) 2)) (/ 1 (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (* t (+ (* -1 (/ t (pow (+ x y) 3))) (/ 1 (pow (+ x y) 2)))) (/ 1 (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (* (- a z) t) #s(hole binary64 (* t (- a z))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (/ a x) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (/ z (pow x 2)) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (+ (* t (- (/ a (pow x 3)) (/ z (pow x 3)))) (/ z (pow x 2))) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 t))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* t (+ 1 (/ (* x (+ 1 (/ y x))) t)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ t x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* t (+ (/ 1 t) (+ (/ 1 x) (/ y (* t x)))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* t (+ (/ 1 x) (/ y (* t x))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x y) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x (+ y (* -1 (/ (pow (+ x y) 2) t)))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (/ (pow (+ x y) 3) (pow t 2)))) (/ (pow (+ x y) 2) t)) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (* -1 (/ (pow (+ x y) 4) (pow t 3))))) (+ (* -1 (/ (pow (+ x y) 3) (pow t 2))) (/ (pow (+ x y) 2) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (/ (* x z) t)) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* x (- (* x z) (* a x))) (pow t 2))) (/ (* x z) t))) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (/ (* x z) t) (/ (* (pow x 2) (- (* x z) (* a x))) (pow t 3)))) (+ (/ (* a x) t) (/ (* x (- (* x z) (* a x))) (pow t 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* t (+ a (/ (* x z) t)))))
#s(approx (+ t x) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* x (+ 1 (/ y x))) t)) 1)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ 1 (/ y x)) t)) (/ 1 x))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ y (* t x))) (/ 1 x))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (/ (pow (+ x y) 2) t)) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (/ (pow (+ x y) 3) t) (pow (+ x y) 2)) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (* -1 (/ (- (/ (pow (+ x y) 4) t) (pow (+ x y) 3)) t)) (pow (+ x y) 2)) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (* x z)) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* x (- (* -1 (* x z)) (* -1 (* a x)))) t))) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow x 2) (- (* -1 (* x z)) (* -1 (* a x)))) t)) (* -1 (* x (- (* -1 (* x z)) (* -1 (* a x)))))) t))) (* -1 (* a x))) t)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* x z) t)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (- z (- b a)) #s(hole binary64 (- z b)))
#s(approx (- b a) #s(hole binary64 b))
#s(approx (- b a) #s(hole binary64 (+ b (* -1 a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (- a z) #s(hole binary64 (- a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 a))
#s(approx (- z (- b a)) #s(hole binary64 (* a (- (+ 1 (/ z a)) (/ b a)))))
#s(approx (- b a) #s(hole binary64 (* -1 a)))
#s(approx (- b a) #s(hole binary64 (* a (- (/ b a) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* a (+ (* -1 (/ (* t z) (* a x))) (/ t x)))))
#s(approx (* (- a z) t) #s(hole binary64 (* a (+ t (* -1 (/ (* t z) a))))))
#s(approx (- a z) #s(hole binary64 (* a (+ 1 (* -1 (/ z a))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* a (+ (/ t (+ t x)) (/ (* x z) (* a (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a (+ t (/ (* x z) a)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (- z b) a)) 1)))))
#s(approx (- b a) #s(hole binary64 (* -1 (* a (+ 1 (* -1 (/ b a)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t x)) (/ (* t z) (* a x)))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* a (+ (* -1 t) (/ (* t z) a))))))
#s(approx (- a z) #s(hole binary64 (* -1 (* a (- (/ z a) 1)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t (+ t x))) (* -1 (/ (* x z) (* a (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 (/ (* x z) a)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (- z (- b a)) #s(hole binary64 (+ a z)))
#s(approx (- z (- b a)) #s(hole binary64 (+ a (+ z (* -1 b)))))
#s(approx (- b a) #s(hole binary64 (- b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 b)))
#s(approx (- z (- b a)) #s(hole binary64 (* b (- (+ (/ a b) (/ z b)) 1))))
#s(approx (- b a) #s(hole binary64 (* b (+ 1 (* -1 (/ a b))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ (+ a z) b)))))))
#s(approx (- b a) #s(hole binary64 (* -1 (* b (- (/ a b) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
Calls

18 calls:

TimeVariablePointExpression
91.0ms
a
@0
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (* (+ 1 (/ (+ t y) x)) x) (+ 1 (/ (+ t y) x)) 1 (/ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (- z (- b a)) (- b a) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (* (- a z) t) x) (* (- a z) t) (- a z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (+ (+ t y) x))
91.0ms
y
@inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (* (+ 1 (/ (+ t y) x)) x) (+ 1 (/ (+ t y) x)) 1 (/ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (- z (- b a)) (- b a) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (* (- a z) t) x) (* (- a z) t) (- a z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (+ (+ t y) x))
4.0ms
t
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (* (+ 1 (/ (+ t y) x)) x) (+ 1 (/ (+ t y) x)) 1 (/ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (- z (- b a)) (- b a) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (* (- a z) t) x) (* (- a z) t) (- a z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (+ (+ t y) x))
4.0ms
a
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (* (+ 1 (/ (+ t y) x)) x) (+ 1 (/ (+ t y) x)) 1 (/ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (- z (- b a)) (- b a) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (* (- a z) t) x) (* (- a z) t) (- a z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (+ (+ t y) x))
4.0ms
z
@-inf
((- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (neg b) b (/ y (+ (+ t y) x)) y (+ (+ t y) x) (* (+ 1 (/ (+ t y) x)) x) (+ 1 (/ (+ t y) x)) 1 (/ (+ t y) x) (+ t y) t x (* (/ (+ y x) (+ (+ t y) x)) z) (/ (+ y x) (+ (+ t y) x)) (+ y x) z (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (- (neg t) y) (neg t) a (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (- z (- b a)) (- b a) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/ (* (- a z) t) x) (* (- a z) t) (- a z) (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/ (+ (* a t) (* z x)) (+ t x)) (+ (* a t) (* z x)) (* z x) (+ t x) (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/ (- (neg t) y) (+ (+ t y) x)) (+ (+ t y) x))

rewrite1.4s (9.6%)

Memory
-36.6MiB live, 473.7MiB allocated; 121ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0279921906
0284220575
0890618934
02861418378
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
540 → 663
Calls
Call 1
Inputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
(fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(neg.f64 b)
b
(/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
y
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)
(+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x))
#s(literal 1 binary64)
(/.f64 (+.f64 t y) x)
(+.f64 t y)
t
x
(*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)
(/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(+.f64 y x)
z
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)
(/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(-.f64 (neg.f64 t) y)
(neg.f64 t)
a
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(-.f64 z (-.f64 b a))
(-.f64 b a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
(/.f64 (*.f64 (-.f64 a z) t) x)
(*.f64 (-.f64 a z) t)
(-.f64 a z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
(/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t))
(fma.f64 a t (*.f64 z x))
(*.f64 z x)
#s(approx (+ t x) t)
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(+.f64 (+.f64 t y) x)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (/ (* y z) (pow (+ t y) 3)))) (+ (* -1 (/ a (pow (+ t y) 2))) (/ z (pow (+ t y) 2))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (/ (* y z) (+ t y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t y))) (+ (* x (- (+ (* x (- (+ (* -1 (/ (* b y) (pow (+ t y) 3))) (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3)))) (/ z (pow (+ t y) 2)))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* x y) (pow (+ t y) 2))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ (* x y) (pow (+ t y) 3)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (* x (- (* -1 (/ (* x y) (pow (+ t y) 4))) (* -1 (/ y (pow (+ t y) 3))))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t y)))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t (+ x y))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t y)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t (+ x y))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ (+ t y) x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ (+ t (+ x y)) x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ (+ t y) x)))
#s(approx x #s(hole binary64 x))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* y z) (+ t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (/ z (+ t y)) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (/ (* y z) (pow (+ t y) 3)) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ z (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4)))) (/ (* y z) (pow (+ t y) 3))) (/ z (pow (+ t y) 2)))) (/ z (+ t y))) (/ (* y z) (pow (+ t y) 2)))) (/ (* y z) (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ y (+ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (/ 1 (+ t y)) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (/ y (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* x (- (+ (* x (- (+ (* x (- (/ 1 (pow (+ t y) 3)) (/ y (pow (+ t y) 4)))) (/ y (pow (+ t y) 3))) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y))) (/ y (pow (+ t y) 2)))) (/ y (+ t y)))))
#s(approx (+ y x) #s(hole binary64 y))
#s(approx (+ y x) #s(hole binary64 (+ x y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (/ (* a x) (+ t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* -1 (/ (* a x) (pow (+ t y) 2))) (/ a (+ t y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* x (+ (* x (+ (* -1 (/ a (pow (+ t y) 2))) (/ (* a x) (pow (+ t y) 3)))) (/ a (+ t y)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 -1))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x (+ t y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* -1 (/ x (pow (+ t y) 2))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* x (+ (* x (- (/ x (pow (+ t y) 3)) (/ 1 (pow (+ t y) 2)))) (/ 1 (+ t y)))) 1)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y z)) (* b y)) (+ t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* x (- (+ (* x (- (+ (* x (- (+ (/ z (pow (+ t y) 3)) (/ (* b y) (pow (+ t y) 4))) (+ (/ a (pow (+ t y) 3)) (/ (* y z) (pow (+ t y) 4))))) (+ (/ a (pow (+ t y) 2)) (/ (* y z) (pow (+ t y) 3)))) (+ (/ z (pow (+ t y) 2)) (/ (* b y) (pow (+ t y) 3))))) (+ (/ z (+ t y)) (/ (* b y) (pow (+ t y) 2)))) (+ (/ a (+ t y)) (/ (* y z) (pow (+ t y) 2))))) (/ (* y z) (+ t y)))) (/ (* b y) (+ t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (* y (- z b))) (* z (+ t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (- (+ (* a (+ t y)) (+ (* x z) (* y (- z b)))) (* z (+ t y))) x)))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (/ (* t (- a z)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (/ z t) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (/ a (pow t 2)) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* x (- (+ (* x (- (+ (* x (- (/ z (pow t 3)) (/ a (pow t 3)))) (/ a (pow t 2))) (/ z (pow t 2)))) (/ z t)) (/ a t))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a t)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (+ (* a t) (* x z))))
#s(approx (* z x) #s(hole binary64 (* x z)))
#s(approx (+ t x) #s(hole binary64 t))
#s(approx (+ t x) #s(hole binary64 (+ t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (+ (* -1 (/ (* a (+ t y)) x)) (/ (* z (+ t y)) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* a (+ t y)) x)) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 3))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* a (pow (+ t y) 2)) (pow x 2)) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (* -1 (/ (* b (* y (pow (+ t y) 2))) (pow x 3))) (+ (/ (* b (* y (+ t y))) (pow x 2)) (/ (* y z) x))))) (+ (* -1 (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ t y)) x))) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x)) x)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ t y) 3)) (pow x 3)))) (+ (* -1 (/ (* y (pow (+ t y) 2)) (pow x 2))) (/ (* y (+ t y)) x))) x)))
#s(approx (+ (+ t y) x) #s(hole binary64 x))
#s(approx (+ (+ t y) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (+ (/ t x) (/ y x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 1))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (+ (/ t x) (/ y x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* y z) x)) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (* y z) (* z (+ t y)))) (pow x 3)))) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (* y z) (* z (+ t y)))) (pow x 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t y)) (pow x 2))) (/ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t y) 2)) (pow x 3)))) (+ (* -1 (/ (* t (+ t y)) (pow x 2))) (/ t x)))))
#s(approx (+ y x) #s(hole binary64 x))
#s(approx (+ y x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (/ (* a (pow (+ t y) 2)) x)) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (/ (* a (pow (+ t y) 2)) x))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (/ (+ (* -1 (* a (+ t y))) (+ (* -1 (/ (* a (pow (+ t y) 3)) (pow x 2))) (+ (/ (* a (pow (+ t y) 2)) x) (/ (* a (pow (+ t y) 4)) (pow x 3))))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t y) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (/ (pow (+ t y) 2) x)) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (/ (pow (+ t y) 2) x))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (/ (+ (* -1 (+ t y)) (+ (* -1 (/ (pow (+ t y) 3) (pow x 2))) (+ (/ (pow (+ t y) 2) x) (/ (pow (+ t y) 4) (pow x 3))))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2))) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (+ (/ (* b y) x) (/ (* z (+ t y)) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (+ (/ (* y z) x) (/ (* (pow (+ t y) 2) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 3))))) (+ (/ (* b y) x) (+ (/ (* z (+ t y)) x) (/ (* (+ t y) (- (+ (* a (+ t y)) (* y z)) (+ (* b y) (* z (+ t y))))) (pow x 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* t (- (* a t) (* t z))) (pow x 2))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ z (+ (/ (* a t) x) (/ (* (pow t 2) (- (* a t) (* t z))) (pow x 3)))) (+ (/ (* t z) x) (/ (* t (- (* a t) (* t z))) (pow x 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x z)))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* x (+ z (/ (* a t) x)))))
#s(approx (+ t x) #s(hole binary64 x))
#s(approx (+ t x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (+ (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 3)))) x)) (* b (* y (+ t y)))) (+ (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y)))))) (* a (pow (+ t y) 2)))) x)) (* b y))) (+ (* -1 (* z (+ t y))) (* a (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* b y)) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (* b (* y (+ t y))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ t y) 2))) (* -1 (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b (* y (+ t y)))) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ t y)) x)) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ t y) 2)) x) (* y (+ t y))) x))) x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ t y) 3)) x) (* y (pow (+ t y) 2))) x)) (* y (+ t y))) x))) x))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* x (- (* -1 (/ (+ t y) x)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* y z)) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* y z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (* y z)) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (* y z)) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 y) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (* (+ t y) (- (* -1 y) (* -1 (+ t y)))) x))) (* -1 (+ t y))) x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 y) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 y) (* -1 (+ t y)))) x)) (* -1 (* (+ t y) (- (* -1 y) (* -1 (+ t y)))))) x))) (* -1 (+ t y))) x)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* x (- (* -1 (/ y x)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 2)) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 3)) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* a (pow (+ t y) 4)) x)) (* a (pow (+ t y) 3))) x)) (* a (pow (+ t y) 2))) x)) (* a (+ t y))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (pow (+ t y) 2) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (pow (+ t y) 3) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ t (+ y (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (pow (+ t y) 4) x)) (pow (+ t y) 3)) x)) (pow (+ t y) 2)) x)))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ t y) 2) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))) x)) (* -1 (* (+ t y) (- (* -1 (- (+ (* a (+ t y)) (* y z)) (* b y))) (* -1 (* z (+ t y))))))) x))) (* -1 (* z (+ t y)))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* a t)) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (* t (- (* -1 (* a t)) (* -1 (* t z)))) x))) (* -1 (* t z))) x)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* a t)) (* -1 (/ (- (* -1 (/ (* (pow t 2) (- (* -1 (* a t)) (* -1 (* t z)))) x)) (* -1 (* t (- (* -1 (* a t)) (* -1 (* t z)))))) x))) (* -1 (* t z))) x)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* x (+ (* -1 z) (* -1 (/ (* a t) x)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* x (- (* -1 (/ t x)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* x z) (+ t x)) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (+ (* -1 (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 4))))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (+ (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))) (/ z (pow (+ t x) 2))))) (/ z (+ t x)))) (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (/ (* x z) (pow (+ t x) 2))))) (/ (* x z) (+ t x))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* y (- (+ (* -1 (/ b (+ t x))) (+ (* y (- (+ (* y (- (+ (* -1 (/ b (pow (+ t x) 3))) (/ z (pow (+ t x) 3))) (/ (* x z) (pow (+ t x) 4)))) (+ (/ b (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 3)))) (/ z (pow (+ t x) 2)))) (/ z (+ t x)))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ t x))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* -1 (/ y (pow (+ t x) 2))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (/ y (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* y (+ (* y (- (* y (+ (* -1 (/ y (pow (+ t x) 4))) (/ 1 (pow (+ t x) 3)))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ t x)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (/ t x)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ y (* x (+ 1 (/ t x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (/ t x))))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ t x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (+ (/ t x) (/ y x))))
#s(approx (+ t y) #s(hole binary64 t))
#s(approx (+ t y) #s(hole binary64 (+ t y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (/ z (+ t x)) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (/ (* x z) (pow (+ t x) 3)) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ z (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 4)))) (/ (* x z) (pow (+ t x) 3))) (/ z (pow (+ t x) 2)))) (/ z (+ t x))) (/ (* x z) (pow (+ t x) 2)))) (/ (* x z) (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ x (+ t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (/ 1 (+ t x)) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (/ x (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (/ 1 (pow (+ t x) 3)) (/ x (pow (+ t x) 4)))) (/ x (pow (+ t x) 3))) (/ 1 (pow (+ t x) 2)))) (/ 1 (+ t x))) (/ x (pow (+ t x) 2)))) (/ x (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a t) (+ t x)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* y (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2))))) (* -1 (/ (* a t) (+ t x))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (* y (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2))))) (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a t) (+ t x))) (* y (+ (* -1 (- (/ a (+ t x)) (/ (* a t) (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ a (pow (+ t x) 3)) (/ (* a t) (pow (+ t x) 4))))) (* -1 (- (/ (* a t) (pow (+ t x) 3)) (/ a (pow (+ t x) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ t (+ t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* y (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2))))) (* -1 (/ t (+ t x))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (* y (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2))))) (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ t (+ t x))) (* y (+ (* -1 (- (/ 1 (+ t x)) (/ t (pow (+ t x) 2)))) (* y (+ (* -1 (* y (- (/ 1 (pow (+ t x) 3)) (/ t (pow (+ t x) 4))))) (* -1 (- (/ t (pow (+ t x) 3)) (/ 1 (pow (+ t x) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 t)))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 y) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a t) (* x z)) (+ t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (/ a (+ t x)) (/ z (+ t x))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3)))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* y (- (+ (* y (- (+ (* y (- (+ (/ a (pow (+ t x) 3)) (/ z (pow (+ t x) 3))) (+ (/ b (pow (+ t x) 3)) (+ (/ (* a t) (pow (+ t x) 4)) (/ (* x z) (pow (+ t x) 4)))))) (+ (/ b (pow (+ t x) 2)) (+ (/ (* a t) (pow (+ t x) 3)) (/ (* x z) (pow (+ t x) 3))))) (+ (/ a (pow (+ t x) 2)) (/ z (pow (+ t x) 2))))) (+ (/ a (+ t x)) (/ z (+ t x)))) (+ (/ b (+ t x)) (+ (/ (* a t) (pow (+ t x) 2)) (/ (* x z) (pow (+ t x) 2)))))) (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* a t) x)) (/ (* t z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* y (- (/ a x) (/ b x))) (/ (* a t) x))) (/ (* t z) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 b)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* z (+ t x)) y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (+ (/ (* z (+ t x)) y) (+ (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 b))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (/ (* b (+ t x)) y) (/ (* x z) y)))) (/ (* z (+ t x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (/ (* x z) y))))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (- (+ z (+ (* -1 b) (+ (* -1 (/ (* b (pow (+ t x) 2)) (pow y 2))) (+ (/ (* b (+ t x)) y) (+ (/ (* b (pow (+ t x) 3)) (pow y 3)) (/ (* x z) y)))))) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2)))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 1))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (+ t x) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (pow (+ t x) 3) (pow y 3)))) (+ (* -1 (/ (pow (+ t x) 2) (pow y 2))) (+ (/ t y) (/ x y))))))
#s(approx (+ (+ t y) x) #s(hole binary64 y))
#s(approx (+ (+ t y) x) #s(hole binary64 (* y (+ 1 (+ (/ t y) (/ x y))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* y (+ 1 (/ (* x (+ 1 (/ t x))) y)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ y x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* y (+ (/ 1 x) (+ (/ 1 y) (/ t (* x y)))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (/ y x)))
#s(approx (/ (+ t y) x) #s(hole binary64 (* y (+ (/ 1 x) (/ t (* x y))))))
#s(approx (+ t y) #s(hole binary64 y))
#s(approx (+ t y) #s(hole binary64 (* y (+ 1 (/ t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (/ (* x z) y)) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))) (/ (* x z) y))) (/ (* z (+ t x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (- (+ z (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (* x z) (* z (+ t x)))) (pow y 3)))) (+ (/ (* z (+ t x)) y) (/ (* (+ t x) (- (* x z) (* z (+ t x)))) (pow y 2))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (/ (* t (+ t x)) (pow y 2))) (/ t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (- (+ 1 (* -1 (/ (* t (pow (+ t x) 2)) (pow y 3)))) (+ (* -1 (/ (* t (+ t x)) (pow y 2))) (/ t y)))))
#s(approx (+ y x) #s(hole binary64 (* y (+ 1 (/ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a t) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) (pow y 3))) (+ (* -1 (/ (- (* a t) (* a (+ t x))) y)) (/ (* (+ t x) (- (* a t) (* a (+ t x)))) (pow y 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x y) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (/ x y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ t x)) (pow y 2))) (+ (/ x y) (/ (* x (pow (+ t x) 2)) (pow y 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 y)))
#s(approx (- (neg t) y) #s(hole binary64 (* y (- (* -1 (/ t y)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (/ (* x z) y)))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (* -1 (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2))) (+ (/ (* a t) y) (/ (* x z) y))))) (+ b (/ (* (+ t x) (- (+ a z) b)) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ z (+ (/ (* a t) y) (+ (/ (* x z) y) (/ (* (pow (+ t x) 2) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 3)))))) (+ b (+ (/ (* (+ t x) (- (+ a z) b)) y) (/ (* (+ t x) (- (+ (* a t) (* x z)) (* (+ t x) (- (+ a z) b)))) (pow y 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (/ a x) (/ b x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* y (- (+ (/ a x) (+ (/ z y) (/ (* a t) (* x y)))) (+ (/ b x) (/ (* t z) (* x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* a (+ t x))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (- (+ (* -1 (* (+ t x) (- (* a t) (* a (+ t x))))) (* -1 (/ (- (* -1 (* (pow (+ t x) 2) (- (* a t) (* a (+ t x))))) (+ (* -1 (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 3)))) y))) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y)) (* a (+ t x)))) (+ (* -1 (* z (+ t x))) (+ (* a t) (* b (+ t x))))) y)))) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (* -1 (* x z)) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (+ (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 2)) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 b) (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (+ (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (/ (* b (pow (+ t x) 3)) y)) (+ (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x)))))) (* b (pow (+ t x) 2)))) y))) (+ (* -1 (* z (+ t x))) (* b (+ t x)))) y))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (pow (+ t x) 2) y)) (* -1 (+ t x))) y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (- (* -1 (/ (pow (+ t x) 3) y)) (* -1 (pow (+ t x) 2))) y)) (* -1 (+ t x))) y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ t x) y)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ (* x (+ 1 (/ t x))) y)) 1)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ 1 (/ t x)) y)) (/ 1 x))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* -1 (* y (- (* -1 (/ t (* x y))) (/ 1 x))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* y (- (* -1 (/ t y)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (* -1 (* x z)) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (* x z)) (* -1 (* z (+ t x))))) y)) (* -1 (* (+ t x) (- (* -1 (* x z)) (* -1 (* z (+ t x))))))) y))) (* -1 (* z (+ t x)))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 x) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (* (+ t x) (- (* -1 x) (* -1 (+ t x)))) y))) (* -1 (+ t x))) y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ (- (+ (* -1 x) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 x) (* -1 (+ t x)))) y)) (* -1 (* (+ t x) (- (* -1 x) (* -1 (+ t x)))))) y))) (* -1 (+ t x))) y)))))
#s(approx (+ y x) #s(hole binary64 (* -1 (* y (- (* -1 (/ x y)) 1)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ t x) (- (* a t) (* a (+ t x)))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* a t) (* a (+ t x)))) y)) (* -1 (* (+ t x) (- (* a t) (* a (+ t x)))))) y)) (* a t)) (* a (+ t x))) y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ t x)) y) x) y)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ t x) 2)) y) (* x (+ t x))) y)) x) y)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* y (+ 1 (/ t y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (- (+ (* -1 a) (* -1 z)) (* -1 b))) (* -1 (/ (- (+ (* -1 (+ (* a t) (* x z))) (* -1 (/ (- (* -1 (/ (* (pow (+ t x) 2) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))) y)) (* -1 (* (+ t x) (- (* -1 (+ (* a t) (* x z))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b))))))) y))) (* (+ t x) (- (+ (* -1 a) (* -1 z)) (* -1 b)))) y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (* -1 (/ (- z b) x))) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* y (- (+ (* -1 (/ a x)) (+ (* -1 (/ (- z b) x)) (* -1 (/ (- (+ z (/ (* a t) x)) (/ (* t z) x)) y)))) (* -1 (/ z x)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx z #s(hole binary64 z))
#s(approx (- z (- b a)) #s(hole binary64 (- a b)))
#s(approx (- z (- b a)) #s(hole binary64 (- (+ a z) b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* a (+ t y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* a (+ t y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (+ (* -1 (/ (* b y) x)) (+ (* z (- 1 (/ t x))) (/ (* a (+ t y)) x)))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (/ (* a t) x)))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (+ (* -1 (/ (* t z) x)) (/ (* a t) x))))
#s(approx (* (- a z) t) #s(hole binary64 (* a t)))
#s(approx (* (- a z) t) #s(hole binary64 (+ (* -1 (* t z)) (* a t))))
#s(approx (- a z) #s(hole binary64 a))
#s(approx (- a z) #s(hole binary64 (+ a (* -1 z))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* a t) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ (/ (* a t) (+ t x)) (/ (* x z) (+ t x)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* z (- (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* z (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* z (+ (* -1 (/ (* b y) (* z (+ t (+ x y))))) (+ (/ x (+ t (+ x y))) (/ y (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 z))
#s(approx (- z (- b a)) #s(hole binary64 (* z (- (+ 1 (/ a z)) (/ b z)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* z (- (+ (/ x (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* a (+ t y)) (* z (+ t (+ x y)))))) (/ (* b y) (* z (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- 1 (/ t x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* z (- (+ 1 (+ (* -1 (/ (* b y) (* x z))) (/ (* a (+ t y)) (* x z)))) (/ t x)))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (/ (* t z) x))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* z (+ (* -1 (/ t x)) (/ (* a t) (* x z))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- a z) t) #s(hole binary64 (* z (+ (* -1 t) (/ (* a t) z)))))
#s(approx (- a z) #s(hole binary64 (* -1 z)))
#s(approx (- a z) #s(hole binary64 (* z (- (/ a z) 1))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (/ (* x z) (+ t x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* z (+ (/ x (+ t x)) (/ (* a t) (* z (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* z (+ x (/ (* a t) z)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (* -1 (/ (* b y) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) z)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (* z (+ x y)) (+ t (+ x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (/ (* b y) (* z (+ t (+ x y)))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (- a b) z)) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (+ x y) (+ t (+ x y)))) (* -1 (/ (- (/ (* a (+ t y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) z)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ y x)) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* z (- (+ (* -1 (/ y x)) (* -1 (/ (+ (* -1 (/ (* b y) x)) (/ (* a (+ t y)) x)) z))) (+ 1 (* -1 (/ (+ t y) x))))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (* z (+ (* -1 (/ (* a t) (* x z))) (/ t x))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* z (+ t (* -1 (/ (* a t) z)))))))
#s(approx (- a z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ a z)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* z (+ (* -1 (/ x (+ t x))) (* -1 (/ (* a t) (* z (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* z (+ (* -1 x) (* -1 (/ (* a t) z)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (* -1 (/ (* b y) (+ x y)))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (+ (* -1 (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4)))) (/ z (pow (+ x y) 3)))))) (+ (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))) (* -1 (/ z (pow (+ x y) 2)))))) (/ (* b y) (pow (+ x y) 2))) (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (/ z (+ x y))))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (* -1 (/ (* b y) (+ x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (/ (* b y) (pow (+ x y) 2)) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (* -1 (/ (* b y) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ z (+ (* -1 (/ (* b y) (+ x y))) (* t (- (+ (* t (- (+ (* -1 (/ (* b y) (pow (+ x y) 3))) (* t (- (/ (* b y) (pow (+ x y) 4)) (/ z (pow (+ x y) 3))))) (* -1 (/ z (pow (+ x y) 2))))) (/ (* b y) (pow (+ x y) 2))) (/ z (+ x y))))))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y (+ x y))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ (* t y) (pow (+ x y) 2))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (/ (* t y) (pow (+ x y) 3)) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (+ (* t (- (* t (- (* -1 (/ (* t y) (pow (+ x y) 4))) (* -1 (/ y (pow (+ x y) 3))))) (/ y (pow (+ x y) 2)))) (/ y (+ x y)))))
#s(approx (+ (+ t y) x) #s(hole binary64 (+ x y)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* x (+ 1 (/ y x)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (+ t (* x (+ 1 (/ y x))))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (+ 1 (/ y x))))
#s(approx t #s(hole binary64 t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* -1 (/ (* t z) (+ x y))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (/ (* t z) (pow (+ x y) 2)) (/ z (+ x y)))))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (+ z (* t (- (* t (- (* -1 (/ (* t z) (pow (+ x y) 3))) (* -1 (/ z (pow (+ x y) 2))))) (/ z (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* -1 (/ t (+ x y))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (/ t (pow (+ x y) 2)) (/ 1 (+ x y)))))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (+ 1 (* t (- (* t (+ (* -1 (/ t (pow (+ x y) 3))) (/ 1 (pow (+ x y) 2)))) (/ 1 (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a y) (+ x y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (* t (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (* -1 (/ (* a y) (+ x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (* t (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2))))) (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 (/ (* a y) (+ x y))) (* t (+ (* -1 (- (/ a (+ x y)) (/ (* a y) (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ a (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (* -1 (- (/ (* a y) (pow (+ x y) 3)) (/ a (pow (+ x y) 2)))))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ y (+ x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (* t (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2))))) (* -1 (/ y (+ x y))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (* t (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2))))) (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (+ (* -1 (/ y (+ x y))) (* t (+ (* -1 (- (/ 1 (+ x y)) (/ y (pow (+ x y) 2)))) (* t (+ (* -1 (* t (- (/ 1 (pow (+ x y) 3)) (/ y (pow (+ x y) 4))))) (* -1 (- (/ y (pow (+ x y) 3)) (/ 1 (pow (+ x y) 2)))))))))))
#s(approx (- (neg t) y) #s(hole binary64 (- (* -1 t) y)))
#s(approx (neg t) #s(hole binary64 (* -1 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (+ (* a y) (* z (+ x y))) (* b y)) (+ x y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ z (+ (* t (- (+ (* t (- (+ (* t (- (+ (/ a (pow (+ x y) 3)) (/ (* b y) (pow (+ x y) 4))) (+ (/ z (pow (+ x y) 3)) (/ (* a y) (pow (+ x y) 4))))) (+ (/ z (pow (+ x y) 2)) (/ (* a y) (pow (+ x y) 3)))) (+ (/ a (pow (+ x y) 2)) (/ (* b y) (pow (+ x y) 3))))) (+ (/ a (+ x y)) (/ (* b y) (pow (+ x y) 2)))) (+ (/ z (+ x y)) (/ (* a y) (pow (+ x y) 2))))) (/ (* a y) (+ x y)))) (/ (* b y) (+ x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* t (- (/ a x) (/ z x))) (+ (/ (* a y) x) (/ (* y (- z b)) x)))) (/ (* y z) x))))
#s(approx (* (- a z) t) #s(hole binary64 (* t (- a z))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (/ a x) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (/ z (pow x 2)) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ z (* t (- (+ (* t (- (+ (* t (- (/ a (pow x 3)) (/ z (pow x 3)))) (/ z (pow x 2))) (/ a (pow x 2)))) (/ a x)) (/ z x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (/ (* z (+ x y)) t)) (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t))) (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) t)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 3))) (+ (/ (* b (* y (+ x y))) (pow t 2)) (/ (* z (+ x y)) t)))) (+ (* -1 a) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 3))) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (+ (/ (* z (pow (+ x y) 2)) (pow t 2)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (+ (* -1 (* b y)) (* z (+ x y))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (/ (* b (* y (+ x y))) t)))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (/ (- (+ (* -1 (* b y)) (+ (* -1 (/ (* b (* y (pow (+ x y) 2))) (pow t 2))) (+ (* z (+ x y)) (+ (/ (* b (* y (+ x y))) t) (/ (* b (* y (pow (+ x y) 3))) (pow t 3)))))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (+ (/ (* z (pow (+ x y) 2)) t) (/ (* z (pow (+ x y) 4)) (pow t 3))))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ y t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (+ y (* -1 (/ (* y (+ x y)) t))) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t)) t)))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (/ (- (+ y (* -1 (/ (* y (pow (+ x y) 3)) (pow t 3)))) (+ (* -1 (/ (* y (pow (+ x y) 2)) (pow t 2))) (/ (* y (+ x y)) t))) t)))
#s(approx (+ (+ t y) x) #s(hole binary64 t))
#s(approx (+ (+ t y) x) #s(hole binary64 (* t (+ 1 (+ (/ x t) (/ y t))))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 t))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* t (+ 1 (/ (* x (+ 1 (/ y x))) t)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (/ t x)))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* t (+ (/ 1 t) (+ (/ 1 x) (/ y (* t x)))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* t (+ (/ 1 x) (/ y (* t x))))))
#s(approx (+ t y) #s(hole binary64 (* t (+ 1 (/ y t)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (* z (+ x y)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (+ (* -1 (/ (* z (pow (+ x y) 2)) t)) (* z (+ x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* z (+ x y)) (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t)) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (/ (- (+ (* -1 (/ (* z (pow (+ x y) 4)) (pow t 3))) (* z (+ x y))) (+ (* -1 (/ (* z (pow (+ x y) 3)) (pow t 2))) (/ (* z (pow (+ x y) 2)) t))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x y) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (+ x (+ y (* -1 (/ (pow (+ x y) 2) t)))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (/ (pow (+ x y) 3) (pow t 2)))) (/ (pow (+ x y) 2) t)) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (/ (- (+ x (+ y (* -1 (/ (pow (+ x y) 4) (pow t 3))))) (+ (* -1 (/ (pow (+ x y) 3) (pow t 2))) (/ (pow (+ x y) 2) t))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (* a y) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (+ (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) (pow t 3))) (+ (* -1 (/ (- (* a y) (* a (+ x y))) t)) (/ (* (+ x y) (- (* a y) (* a (+ x y)))) (pow t 2)))))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (/ x t) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (/ x t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (+ (* -1 (/ (* x (+ x y)) (pow t 2))) (+ (/ x t) (/ (* x (pow (+ x y) 2)) (pow t 3)))) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* t (- (* -1 (/ y t)) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (/ (* z (+ x y)) t))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2))) (+ (/ (* a y) t) (/ (* z (+ x y)) t)))) (+ (/ (* a (+ x y)) t) (/ (* b y) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ a (+ (/ (* a y) t) (+ (/ (* z (+ x y)) t) (/ (* (pow (+ x y) 2) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 3))))) (+ (/ (* a (+ x y)) t) (+ (/ (* b y) t) (/ (* (+ x y) (- (+ (* a y) (* z (+ x y))) (+ (* a (+ x y)) (* b y)))) (pow t 2)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (/ a x) (/ z x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* t (- (+ (/ a x) (+ (/ z t) (+ (/ (* a y) (* t x)) (/ (* y (- z b)) (* t x))))) (+ (/ z x) (/ (* y z) (* t x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (/ (* x z) t)) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (* -1 (/ (* x (- (* x z) (* a x))) (pow t 2))) (/ (* x z) t))) (/ (* a x) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (- (+ a (+ (/ (* x z) t) (/ (* (pow x 2) (- (* x z) (* a x))) (pow t 3)))) (+ (/ (* a x) t) (/ (* x (- (* x z) (* a x))) (pow t 2))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* t (+ a (/ (* x z) t)))))
#s(approx (+ t x) #s(hole binary64 (* t (+ 1 (/ x t)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* a (+ x y)) (* b y))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (* -1 (/ (- (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (* (+ x y) (- (* a y) (* a (+ x y))))) (+ (* -1 (/ (- (+ (* -1 (* (pow (+ x y) 2) (- (* a y) (* a (+ x y))))) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y))))) (* z (pow (+ x y) 2))) t)) (+ (* a (+ x y)) (* b y)))) (* a y)) t)) (* -1 a))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* b y)) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (* b (* y (+ x y))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 2))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (+ (* -1 (/ (- (+ (* -1 (/ (- (+ (* -1 (/ (- (* b (* y (pow (+ x y) 3))) (* z (pow (+ x y) 4))) t)) (* b (* y (pow (+ x y) 2)))) (* z (pow (+ x y) 3))) t)) (* b (* y (+ x y)))) (* z (pow (+ x y) 2))) t)) (* b y))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (/ (* y (+ x y)) t)) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (/ (* y (pow (+ x y) 2)) t) (* y (+ x y))) t))) t))))
#s(approx (/ y (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (/ (* y (pow (+ x y) 3)) t) (* y (pow (+ x y) 2))) t)) (* y (+ x y))) t))) t))))
#s(approx (+ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ x y) t)) 1)))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* x (+ 1 (/ y x))) t)) 1)))))
#s(approx (+ 1 (/ (+ t y) x)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ 1 (/ y x)) t)) (/ 1 x))))))
#s(approx (/ (+ t y) x) #s(hole binary64 (* -1 (* t (- (* -1 (/ y (* t x))) (/ 1 x))))))
#s(approx (+ t y) #s(hole binary64 (* -1 (* t (- (* -1 (/ y t)) 1)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (/ (* z (pow (+ x y) 2)) t)) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (/ (* z (pow (+ x y) 3)) t) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (* z (+ x y))) (* -1 (/ (- (* -1 (/ (- (/ (* z (pow (+ x y) 4)) t) (* z (pow (+ x y) 3))) t)) (* z (pow (+ x y) 2))) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (/ (pow (+ x y) 2) t)) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (/ (pow (+ x y) 3) t) (pow (+ x y) 2)) t))) t))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(hole binary64 (* -1 (/ (+ (* -1 (+ x y)) (* -1 (/ (- (* -1 (/ (- (/ (pow (+ x y) 4) t) (pow (+ x y) 3)) t)) (pow (+ x y) 2)) t))) t))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (* (+ x y) (- (* a y) (* a (+ x y)))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (+ (* -1 a) (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* a y) (* a (+ x y)))) t)) (* -1 (* (+ x y) (- (* a y) (* a (+ x y)))))) t)) (* a y)) (* a (+ x y))) t)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (/ (* x (+ x y)) t) x) t)) 1)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(hole binary64 (- (* -1 (/ (- (* -1 (/ (- (/ (* x (pow (+ x y) 2)) t) (* x (+ x y))) t)) x) t)) 1)))
#s(approx (- (neg t) y) #s(hole binary64 (* -1 (* t (+ 1 (/ y t))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (/ (- (* -1 (/ (* (pow (+ x y) 2) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))) t)) (* -1 (* (+ x y) (- (* -1 (- (+ (* a y) (* z (+ x y))) (* b y))) (* -1 (* a (+ x y))))))) t))) (* -1 (* a (+ x y)))) t)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (* -1 (/ a x)) (* -1 (/ z x)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ a x)) (* -1 (/ (- (+ z (+ (/ (* a y) x) (/ (* y (- z b)) x))) (/ (* y z) x)) t))) (* -1 (/ z x)))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (* -1 (* x z)) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (* x (- (* -1 (* x z)) (* -1 (* a x)))) t))) (* -1 (* a x))) t)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (+ a (* -1 (/ (- (+ (* -1 (* x z)) (* -1 (/ (- (* -1 (/ (* (pow x 2) (- (* -1 (* x z)) (* -1 (* a x)))) t)) (* -1 (* x (- (* -1 (* x z)) (* -1 (* a x)))))) t))) (* -1 (* a x))) t)))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* t (+ (* -1 a) (* -1 (/ (* x z) t)))))))
#s(approx (+ t x) #s(hole binary64 (* -1 (* t (- (* -1 (/ x t)) 1)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) #s(hole binary64 (* -1 (/ (* a (+ t y)) (+ t (+ x y))))))
#s(approx a #s(hole binary64 a))
#s(approx (- z (- b a)) #s(hole binary64 (- z b)))
#s(approx (- b a) #s(hole binary64 b))
#s(approx (- b a) #s(hole binary64 (+ b (* -1 a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (- (* z (+ x y)) (* b y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (- (+ (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y))))) (/ (* z (+ x y)) (+ t (+ x y)))) (/ (* b y) (+ t (+ x y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* a (+ (/ t x) (/ y x))) (/ (* y (- z b)) x))) (/ (* z (+ t y)) x))))
#s(approx (- a z) #s(hole binary64 (- a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (- (+ (* -1 (/ (* b y) (* a (+ t (+ x y))))) (/ (* z (+ x y)) (* a (+ t (+ x y))))) (* -1 (/ (+ t y) (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 a))
#s(approx (- z (- b a)) #s(hole binary64 (* a (- (+ 1 (/ z a)) (/ b a)))))
#s(approx (- b a) #s(hole binary64 (* -1 a)))
#s(approx (- b a) #s(hole binary64 (* a (- (/ b a) 1))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (* a (+ t y)) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* a (- (+ (/ t (+ t (+ x y))) (+ (/ y (+ t (+ x y))) (/ (* z (+ x y)) (* a (+ t (+ x y)))))) (/ (* b y) (* a (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (+ (/ t x) (/ y x)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* a (- (+ (/ t x) (+ (/ y x) (+ (/ z a) (/ (* y (- z b)) (* a x))))) (/ (* z (+ t y)) (* a x))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* a (+ (* -1 (/ (* t z) (* a x))) (/ t x)))))
#s(approx (* (- a z) t) #s(hole binary64 (* a (+ t (* -1 (/ (* t z) a))))))
#s(approx (- a z) #s(hole binary64 (* a (+ 1 (* -1 (/ z a))))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* a (+ (/ t (+ t x)) (/ (* x z) (* a (+ t x)))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* a (+ t (/ (* x z) a)))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* a (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) a)) (+ (/ t (+ t (+ x y))) (/ y (+ t (+ x y)))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (- z b) a)) 1)))))
#s(approx (- b a) #s(hole binary64 (* -1 (* a (+ 1 (* -1 (/ b a)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) (+ t (+ x y)))) (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (/ (* b y) (+ t (+ x y)))) a)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (/ (* a (+ t y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ (+ t y) x)) (* -1 (/ (- (+ z (/ (* y (- z b)) x)) (/ (* z (+ t y)) x)) a)))))))
#s(approx (/ (* (- a z) t) x) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t x)) (/ (* t z) (* a x)))))))
#s(approx (* (- a z) t) #s(hole binary64 (* -1 (* a (+ (* -1 t) (/ (* t z) a))))))
#s(approx (- a z) #s(hole binary64 (* -1 (* a (- (/ z a) 1)))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) #s(hole binary64 (* -1 (* a (+ (* -1 (/ t (+ t x))) (* -1 (/ (* x z) (* a (+ t x)))))))))
#s(approx (+ (* a t) (* z x)) #s(hole binary64 (* -1 (* a (+ (* -1 t) (* -1 (/ (* x z) a)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (- (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y)))) (* -1 (/ (* a (+ t y)) (+ t (+ x y)))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (/ (* z (+ x y)) (+ t (+ x y))))))
#s(approx (neg b) #s(hole binary64 (* -1 b)))
#s(approx b #s(hole binary64 b))
#s(approx (- z (- b a)) #s(hole binary64 (+ a z)))
#s(approx (- z (- b a)) #s(hole binary64 (+ a (+ z (* -1 b)))))
#s(approx (- b a) #s(hole binary64 (- b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (/ (+ (* a (+ t y)) (* z (+ x y))) (+ t (+ x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (+ (* -1 (/ (* b y) (+ t (+ x y)))) (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (- (+ z (+ (* -1 (/ (* b y) x)) (+ (/ (* a (+ t y)) x) (/ (* y z) x)))) (/ (* z (+ t y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* b (- (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))) (* -1 (/ (* a (+ t y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 b)))
#s(approx (- z (- b a)) #s(hole binary64 (* b (- (+ (/ a b) (/ z b)) 1))))
#s(approx (- b a) #s(hole binary64 (* b (+ 1 (* -1 (/ a b))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (/ (* b y) (+ t (+ x y))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* b (+ (* -1 (/ y (+ t (+ x y)))) (+ (/ (* a (+ t y)) (* b (+ t (+ x y)))) (/ (* z (+ x y)) (* b (+ t (+ x y)))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (/ (* b y) x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* b (- (+ (* -1 (/ y x)) (+ (/ z b) (+ (/ (* a (+ t y)) (* b x)) (/ (* y z) (* b x))))) (/ (* z (+ t y)) (* b x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (/ (* z (+ x y)) (+ t (+ x y))) (* -1 (/ (* a (+ t y)) (+ t (+ x y))))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (* z (+ x y)) (* b (+ t (+ x y))))) (/ y (+ t (+ x y))))))))
#s(approx (- z (- b a)) #s(hole binary64 (* -1 (* b (+ 1 (* -1 (/ (+ a z) b)))))))
#s(approx (- b a) #s(hole binary64 (* -1 (* b (- (/ a b) 1)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (+ (/ (* a (+ t y)) (+ t (+ x y))) (/ (* z (+ x y)) (+ t (+ x y)))) b)) (/ y (+ t (+ x y))))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (- (+ z (+ (/ (* a (+ t y)) x) (/ (* y z) x))) (/ (* z (+ t y)) x)) b)) (/ y x))))))
Outputs
(fma.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (neg.f64 b) (fma.f64 z (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)))
(fma.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (neg.f64 b) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (fma.f64 z (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)))
(fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(fma.f64 b (neg.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))) (fma.f64 z (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)))
(fma.f64 b (neg.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(-.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (-.f64 (*.f64 (/.f64 (neg.f64 (+.f64 y x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)))
(-.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (fma.f64 (/.f64 (neg.f64 (+.f64 y x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z (/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))))
(-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(+.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (fma.f64 z (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)))
(+.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (/.f64 (-.f64 (*.f64 (+.f64 y x) z) (*.f64 (-.f64 (neg.f64 t) y) a)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(+.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
(/.f64 (fma.f64 (neg.f64 y) b (*.f64 (+.f64 y x) z)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(/.f64 (fma.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (*.f64 (+.f64 y x) z))) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(fma.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (neg.f64 b) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(fma.f64 b (neg.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(-.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (neg.f64 (+.f64 y x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(+.f64 (/.f64 (*.f64 (neg.f64 y) b) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(*.f64 #s(literal -1 binary64) b)
(*.f64 b #s(literal -1 binary64))
(neg.f64 b)
b
(/.f64 (neg.f64 y) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(neg.f64 (/.f64 y (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))))
(neg.f64 (/.f64 (neg.f64 y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
y
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x (*.f64 x (/.f64 y x)))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x (*.f64 (/.f64 y x) x))
(fma.f64 x (+.f64 #s(literal 1 binary64) (/.f64 t x)) (*.f64 x (/.f64 y x)))
(fma.f64 x (+.f64 #s(literal 1 binary64) (/.f64 t x)) (*.f64 (/.f64 y x) x))
(+.f64 (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x) (*.f64 x (/.f64 y x)))
(+.f64 (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x) (*.f64 (/.f64 y x) x))
(+.f64 x (*.f64 x (/.f64 (+.f64 t y) x)))
(+.f64 x (*.f64 (/.f64 (+.f64 t y) x) x))
(+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) (/.f64 y x))
(+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x))
#s(literal 1 binary64)
(*.f64 (/.f64 (+.f64 t y) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x))
(*.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (+.f64 t y) #s(literal -1 binary64)))
(*.f64 (/.f64 (+.f64 t y) x) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x))
(/.f64 (fma.f64 (neg.f64 t) (neg.f64 x) (*.f64 (neg.f64 x) (neg.f64 y))) (*.f64 x x))
(/.f64 (fma.f64 (neg.f64 x) t (*.f64 (neg.f64 x) y)) (*.f64 (neg.f64 x) x))
(/.f64 (*.f64 x (+.f64 t y)) (*.f64 x x))
(/.f64 (neg.f64 (+.f64 t y)) (neg.f64 x))
(/.f64 (+.f64 t y) x)
(neg.f64 (/.f64 (+.f64 t y) (neg.f64 x)))
(fma.f64 (/.f64 t #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) x) (/.f64 y x))
(fma.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 t #s(literal -1 binary64)) (/.f64 y x))
(fma.f64 (/.f64 #s(literal 1 binary64) x) t (/.f64 y x))
(fma.f64 (/.f64 t x) #s(literal 1 binary64) (/.f64 y x))
(fma.f64 #s(literal 1 binary64) (/.f64 t x) (/.f64 y x))
(+.f64 (/.f64 (*.f64 x t) (*.f64 x x)) (/.f64 (*.f64 x y) (*.f64 x x)))
(+.f64 (/.f64 t x) (/.f64 y x))
(*.f64 #s(literal 1 binary64) (+.f64 t y))
(+.f64 t y)
t
x
(*.f64 z (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)
(/.f64 (*.f64 (neg.f64 (+.f64 y x)) z) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (*.f64 (+.f64 y x) z) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(fma.f64 z (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 z (/.f64 x #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))))
(fma.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z (*.f64 (/.f64 x #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(+.f64 (*.f64 z (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))) (*.f64 z (/.f64 x #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))))
(+.f64 (*.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z) (*.f64 (/.f64 x #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z))
(/.f64 (fma.f64 (neg.f64 y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (*.f64 (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) x)) (*.f64 (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (fma.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) x)) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (neg.f64 (+.f64 y x)) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(neg.f64 (/.f64 (neg.f64 (+.f64 y x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(+.f64 (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (/.f64 x #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(+.f64 y x)
z
(*.f64 a (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a)
(/.f64 (*.f64 (neg.f64 (-.f64 (neg.f64 t) y)) a) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (neg.f64 y))) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))))
(/.f64 (-.f64 (*.f64 (neg.f64 t) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) y)) (*.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (neg.f64 #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x)))
(neg.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(-.f64 (/.f64 (neg.f64 t) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))))
(-.f64 (neg.f64 t) y)
(*.f64 #s(literal -1 binary64) t)
(*.f64 t #s(literal -1 binary64))
(neg.f64 t)
a
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(-.f64 (-.f64 z b) (neg.f64 a))
(-.f64 z (-.f64 b a))
(+.f64 (-.f64 z b) a)
(+.f64 z (+.f64 (neg.f64 b) a))
(+.f64 z (-.f64 (neg.f64 b) (neg.f64 a)))
(-.f64 b a)
(+.f64 b (neg.f64 a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
(*.f64 (/.f64 (-.f64 a z) x) t)
(*.f64 (*.f64 (neg.f64 t) (/.f64 (-.f64 a z) x)) #s(literal -1 binary64))
(*.f64 (-.f64 a z) (/.f64 t x))
(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) (/.f64 (-.f64 a z) x)))
(*.f64 t (/.f64 (-.f64 a z) x))
(/.f64 (*.f64 (*.f64 x (-.f64 a z)) t) (*.f64 x x))
(/.f64 (*.f64 (neg.f64 (*.f64 (-.f64 a z) (neg.f64 t))) #s(literal -1 binary64)) (neg.f64 x))
(/.f64 (*.f64 (*.f64 (-.f64 a z) (neg.f64 t)) #s(literal -1 binary64)) x)
(/.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 a z) (neg.f64 t)))) (neg.f64 x))
(/.f64 (-.f64 (*.f64 (*.f64 (neg.f64 a) t) (neg.f64 x)) (*.f64 (neg.f64 x) (*.f64 (neg.f64 t) z))) (*.f64 x x))
(/.f64 (-.f64 (*.f64 (*.f64 (neg.f64 a) t) x) (*.f64 (neg.f64 x) (*.f64 z t))) (*.f64 (neg.f64 x) x))
(/.f64 (-.f64 (*.f64 (*.f64 a t) (neg.f64 x)) (*.f64 x (*.f64 (neg.f64 t) z))) (*.f64 (neg.f64 x) x))
(/.f64 (-.f64 (*.f64 (*.f64 a t) x) (*.f64 x (*.f64 z t))) (*.f64 x x))
(/.f64 (neg.f64 (*.f64 (-.f64 a z) (neg.f64 t))) (neg.f64 (neg.f64 x)))
(/.f64 (neg.f64 (*.f64 (-.f64 a z) (neg.f64 t))) x)
(/.f64 (*.f64 (-.f64 a z) (neg.f64 t)) (neg.f64 x))
(/.f64 (*.f64 (-.f64 a z) t) x)
(neg.f64 (/.f64 (*.f64 (-.f64 a z) t) (neg.f64 x)))
(neg.f64 (*.f64 (neg.f64 t) (/.f64 (-.f64 a z) x)))
(-.f64 (*.f64 (/.f64 t x) a) (*.f64 (/.f64 t x) z))
(*.f64 (-.f64 a z) t)
(*.f64 t (-.f64 a z))
(fma.f64 a t (*.f64 (neg.f64 t) z))
(fma.f64 t a (*.f64 (neg.f64 t) z))
(-.f64 (*.f64 a t) (*.f64 z t))
(+.f64 (*.f64 a t) (*.f64 (neg.f64 t) z))
(-.f64 a z)
(+.f64 a (neg.f64 z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
(/.f64 (fma.f64 (*.f64 a t) #s(approx (+ t x) t) (*.f64 #s(approx (+ t x) t) (*.f64 z x))) (*.f64 #s(approx (+ t x) t) #s(approx (+ t x) t)))
(/.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (neg.f64 #s(approx (+ t x) t)))
(/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t))
(neg.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (neg.f64 #s(approx (+ t x) t))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) #s(approx (+ t x) t)))
(-.f64 (/.f64 (*.f64 a t) #s(approx (+ t x) t)) (/.f64 (*.f64 (neg.f64 x) z) #s(approx (+ t x) t)))
(+.f64 (/.f64 (*.f64 (neg.f64 a) t) (neg.f64 #s(approx (+ t x) t))) (/.f64 (*.f64 (neg.f64 x) z) (neg.f64 #s(approx (+ t x) t))))
(+.f64 (/.f64 (*.f64 a t) #s(approx (+ t x) t)) (/.f64 (*.f64 z x) #s(approx (+ t x) t)))
(fma.f64 a t (*.f64 z x))
(fma.f64 t a (*.f64 z x))
(-.f64 (*.f64 a t) (*.f64 (neg.f64 x) z))
(+.f64 (*.f64 a t) (*.f64 z x))
(*.f64 z x)
(*.f64 x z)
#s(approx (+ t x) t)
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x)))
(+.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
(*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a)
(*.f64 a (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (neg.f64 (-.f64 (neg.f64 t) y)) a) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (*.f64 (-.f64 (neg.f64 t) y) a) (+.f64 (+.f64 t y) x))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (neg.f64 (+.f64 (+.f64 t y) x))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 y))) (*.f64 (+.f64 (+.f64 t y) x) (neg.f64 (+.f64 (+.f64 t y) x))))
(/.f64 (-.f64 (*.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (*.f64 (+.f64 (+.f64 t y) x) y)) (*.f64 (+.f64 (+.f64 t y) x) (+.f64 (+.f64 t y) x)))
(/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (neg.f64 (+.f64 (+.f64 t y) x)))
(/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x))
(neg.f64 (/.f64 (neg.f64 (-.f64 (neg.f64 t) y)) (+.f64 (+.f64 t y) x)))
(-.f64 (/.f64 (neg.f64 t) (+.f64 (+.f64 t y) x)) (/.f64 y (+.f64 (+.f64 t y) x)))
(fma.f64 #s(literal 1 binary64) (+.f64 t y) x)
(+.f64 (+.f64 t y) x)
(+.f64 t (+.f64 y x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (+.f64 t y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 b (neg.f64 (/.f64 y (+.f64 t y))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (*.f64 (-.f64 (fma.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (+.f64 (neg.f64 a) z) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y)))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x)) (fma.f64 y (/.f64 z (+.f64 t y)) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 (+.f64 (neg.f64 a) z) (*.f64 (+.f64 t y) (+.f64 t y)))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y))))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (+.f64 t y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 x (fma.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 t y)) (fma.f64 (fma.f64 x (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (fma.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (pow.f64 (+.f64 t y) #s(literal 4 binary64)))) x (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))))) (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (-.f64 (*.f64 y b) (*.f64 z y)) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 x y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) x (/.f64 y (+.f64 t y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 x (-.f64 (*.f64 (fma.f64 (neg.f64 x) (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 y (+.f64 t y))))
#s(approx (+ (+ t y) x) (+.f64 t y))
#s(approx (+ (+ t y) x) (+.f64 (+.f64 t x) y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (+.f64 t y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (+.f64 (+.f64 t x) y))
#s(approx (+ 1 (/ (+ t y) x)) (/.f64 (+.f64 t y) x))
#s(approx (+ 1 (/ (+ t y) x)) (/.f64 (+.f64 (+.f64 t x) y) x))
#s(approx (/ (+ t y) x) (/.f64 (+.f64 t y) x))
#s(approx x x)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 y (/.f64 z (+.f64 t y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 x (fma.f64 (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 x (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (-.f64 (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))))) (-.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 y (+.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t y)) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) x (/.f64 y (+.f64 t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t y)) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))))) x (/.f64 y (+.f64 t y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 x (-.f64 (fma.f64 x (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64)))) x (/.f64 y (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 #s(literal 1 binary64) (+.f64 t y))) (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 y (+.f64 t y))))
#s(approx (+ y x) y)
#s(approx (+ y x) (+.f64 x y))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 a (+.f64 #s(literal -1 binary64) (/.f64 x (+.f64 t y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (/.f64 (neg.f64 a) (*.f64 (+.f64 t y) (+.f64 t y))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (neg.f64 a) (*.f64 (fma.f64 (+.f64 (/.f64 (neg.f64 a) (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 a x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 a (+.f64 t y))) x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) #s(literal -1 binary64))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (/.f64 (neg.f64 x) (*.f64 (+.f64 t y) (+.f64 t y))) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (*.f64 (-.f64 (/.f64 x (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t y) (+.f64 t y)))) x) x (-.f64 (/.f64 x (+.f64 t y)) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (+.f64 t y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (-.f64 (*.f64 y (/.f64 z (+.f64 t y))) (*.f64 b (/.f64 y (+.f64 t y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (-.f64 (-.f64 (+.f64 (/.f64 z (+.f64 t y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y))))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) (/.f64 a (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) (*.f64 y (/.f64 z (pow.f64 (+.f64 t y) #s(literal 4 binary64))))) x (+.f64 (/.f64 a (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))))) (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x (/.f64 z (+.f64 t y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 t y)))) (/.f64 a (+.f64 t y))) (/.f64 (*.f64 z y) (*.f64 (+.f64 t y) (+.f64 t y)))) x (*.f64 y (/.f64 z (+.f64 t y))))) (*.f64 b (/.f64 y (+.f64 t y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (fma.f64 a (+.f64 t y) (fma.f64 z x (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))))) x))
#s(approx (/ (* (- a z) t) x) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) a)
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 (-.f64 z a) x) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (fma.f64 (/.f64 (-.f64 z a) (*.f64 (*.f64 t t) t)) x (/.f64 (-.f64 a z) (*.f64 t t))) x (/.f64 (-.f64 z a) t)) x)))
#s(approx (+ (* a t) (* z x)) (*.f64 a t))
#s(approx (+ (* a t) (* z x)) (fma.f64 a t (*.f64 z x)))
#s(approx (* z x) (*.f64 z x))
#s(approx (+ t x) t)
#s(approx (+ t x) (+.f64 t x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) z)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (-.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 z y)) x) (/.f64 (fma.f64 (neg.f64 (+.f64 t y)) a (*.f64 z (+.f64 t y))) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x))) (/.f64 (fma.f64 (neg.f64 a) (+.f64 t y) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (fma.f64 (/.f64 (+.f64 t y) (neg.f64 x)) a (+.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) a (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 z (-.f64 (-.f64 y t) y)))) (*.f64 (*.f64 x x) x)) (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x))))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z)
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 b (/.f64 (*.f64 (+.f64 t y) y) (*.f64 x x)) (/.f64 (*.f64 z y) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (+.f64 z (fma.f64 (neg.f64 b) (/.f64 y x) (/.f64 (fma.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) y) b (fma.f64 (*.f64 (*.f64 (+.f64 t y) y) b) x (*.f64 (*.f64 x x) (*.f64 z y)))) (*.f64 (*.f64 x x) x)))) (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 z (-.f64 (-.f64 y t) y)) (fma.f64 (*.f64 z (+.f64 t y)) (*.f64 x x) (*.f64 x (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y))))) (*.f64 (*.f64 x x) x))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (*.f64 y (/.f64 (+.f64 t y) x))) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 t y) x) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 x x)) (*.f64 y (/.f64 (+.f64 t y) x))))) x))
#s(approx (+ (+ t y) x) x)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) x)
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))
#s(approx (+ 1 (/ (+ t y) x)) #s(literal 1 binary64))
#s(approx (+ 1 (/ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (neg.f64 (+.f64 t y)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 x x)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 (+.f64 z (fma.f64 y (/.f64 z x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x)))) (fma.f64 z (/.f64 (+.f64 t y) x) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 y t) y)) (+.f64 t y)) (*.f64 x x)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) #s(literal 1 binary64))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t y) t) (*.f64 x x))) (/.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (fma.f64 t (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (*.f64 (*.f64 x x) x)) (fma.f64 (neg.f64 t) (/.f64 (+.f64 t y) (*.f64 x x)) (/.f64 t x)))))
#s(approx (+ y x) x)
#s(approx (+ y x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (+.f64 t y) x) (neg.f64 a)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (neg.f64 a) (+.f64 t y) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 (neg.f64 (+.f64 t y)) a (/.f64 (fma.f64 (neg.f64 a) (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x)) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (*.f64 a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) (*.f64 x x))))) (*.f64 a (+.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (+.f64 t y) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (+.f64 (neg.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x))) (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) (*.f64 (*.f64 x x) x))) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (neg.f64 (+.f64 t y)) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (*.f64 x x)) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 z (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z y)) x)) (/.f64 (*.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 (*.f64 x x) x))) (/.f64 (fma.f64 y b (*.f64 z (+.f64 t y))) x)) (/.f64 (*.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (+.f64 t y)) (*.f64 x x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z)
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) z)
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (fma.f64 (neg.f64 t) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x x)) (/.f64 (*.f64 (-.f64 a z) t) x))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 (+.f64 z (fma.f64 (/.f64 t x) a (/.f64 (*.f64 (*.f64 t t) (*.f64 (-.f64 a z) t)) (*.f64 (*.f64 x x) x)))) (*.f64 t (+.f64 (/.f64 z x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x x))))))
#s(approx (+ (* a t) (* z x)) (*.f64 z x))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 z (*.f64 (/.f64 t x) a)) x))
#s(approx (+ t x) x)
#s(approx (+ t x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (neg.f64 (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a))) x))) (-.f64 (*.f64 y b) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a)))) x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (-.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) a))) (neg.f64 x)) (fma.f64 (*.f64 (+.f64 t y) y) b (-.f64 (*.f64 (neg.f64 (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y))) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)))) x))) (*.f64 y b)) (*.f64 (+.f64 t y) (+.f64 (neg.f64 z) a))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (neg.f64 (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) x))) (fma.f64 y b (*.f64 z (+.f64 t y)))) x)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (/.f64 (fma.f64 (neg.f64 y) z (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) y) b (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) (*.f64 z (-.f64 (-.f64 y t) y)))) x) (neg.f64 (fma.f64 (*.f64 (+.f64 t y) y) b (*.f64 (neg.f64 (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))))) x) (fma.f64 y b (*.f64 z (+.f64 t y))))) x)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (*.f64 y (/.f64 (+.f64 t y) x))) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (+.f64 t y))) x)) x))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (+.f64 t y) (+.f64 t y)))) (neg.f64 x)) (*.f64 (+.f64 t y) y)) x)) (neg.f64 x)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) #s(literal 1 binary64))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 y) z (fma.f64 (+.f64 t y) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 z (+.f64 t y)))) x)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x) (*.f64 (neg.f64 (+.f64 t y)) (*.f64 z (-.f64 (-.f64 y t) y)))) x))) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 y) (-.f64 (*.f64 (+.f64 t y) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x)) (+.f64 t y))) x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 y) (-.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 (neg.f64 (-.f64 (-.f64 y t) y)) x) (*.f64 (neg.f64 (-.f64 (-.f64 y t) y)) (+.f64 t y))) x) (+.f64 t y))) x)))
#s(approx (+ y x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 y) x) #s(literal 1 binary64))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (fma.f64 a (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x) (*.f64 (neg.f64 a) (+.f64 t y))) x))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)) x) (*.f64 (neg.f64 (*.f64 (+.f64 t y) (+.f64 t y))) a)) x) (*.f64 a (+.f64 t y))) (neg.f64 x)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (*.f64 (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) a)) x) (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) a)) x) (*.f64 (neg.f64 a) (+.f64 t y))) x))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (*.f64 (+.f64 t y) (+.f64 t y)) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 t y) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (pow.f64 (+.f64 t y) #s(literal 4 binary64)) x) (neg.f64 (*.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (+.f64 t y)))) x) (*.f64 (+.f64 t y) (+.f64 t y))) x)) (neg.f64 x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y))) (fma.f64 (+.f64 t y) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x) (*.f64 z (+.f64 t y)))) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a (+.f64 t y) (fma.f64 (-.f64 z b) y (/.f64 (fma.f64 (*.f64 (+.f64 t y) (+.f64 t y)) (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x) (*.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) (neg.f64 (+.f64 t y)))) x)))) (*.f64 z (+.f64 t y))) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 z (/.f64 (+.f64 (neg.f64 (*.f64 t (+.f64 a (*.f64 (neg.f64 t) (/.f64 (-.f64 a z) x))))) (*.f64 z t)) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 a t (/.f64 (fma.f64 (*.f64 t t) (/.f64 (*.f64 (-.f64 a z) t) x) (*.f64 (*.f64 (-.f64 a z) (neg.f64 t)) t)) x))) (*.f64 z t)) x)))
#s(approx (+ (* a t) (* z x)) (*.f64 (neg.f64 x) (-.f64 (neg.f64 z) (*.f64 (/.f64 t x) a))))
#s(approx (+ t x) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 t) x) #s(literal 1 binary64))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (-.f64 (-.f64 (fma.f64 (-.f64 (fma.f64 y (-.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (neg.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x))))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x))) (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (-.f64 (*.f64 z x) (*.f64 (neg.f64 a) t)) (+.f64 t x))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 y (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (fma.f64 (-.f64 (+.f64 (/.f64 (neg.f64 b) (+.f64 t x)) (fma.f64 y (-.f64 (fma.f64 (-.f64 (/.f64 (+.f64 (neg.f64 b) z) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 z (+.f64 t x)))) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 t x)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (/.f64 (neg.f64 y) (*.f64 (+.f64 t x) (+.f64 t x))) y (/.f64 y (+.f64 t x))))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 y) (pow.f64 (+.f64 t x) #s(literal 4 binary64))) y (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y))
#s(approx y y)
#s(approx (+ (+ t y) x) (+.f64 t x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (+.f64 y (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x)))
#s(approx (+ 1 (/ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 t x)))
#s(approx (/ (+ t y) x) (/.f64 t x))
#s(approx (/ (+ t y) x) (/.f64 (+.f64 t y) x))
#s(approx (+ t y) t)
#s(approx (+ t y) (+.f64 t y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 y (fma.f64 (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (fma.f64 (fma.f64 y (fma.f64 (-.f64 (/.f64 z (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 x (/.f64 z (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 z x) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 z (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 z (+.f64 t x)) (/.f64 (*.f64 z x) (*.f64 (+.f64 t x) (+.f64 t x))))) y (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 x (+.f64 t x)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 x (+.f64 t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 (fma.f64 (-.f64 (/.f64 x (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 x (+.f64 t x))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (fma.f64 y (-.f64 (fma.f64 y (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 x (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 x (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (+.f64 t x))) (/.f64 x (*.f64 (+.f64 t x) (+.f64 t x)))) (/.f64 x (+.f64 t x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (neg.f64 a) (/.f64 t (+.f64 t x))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))) y (*.f64 (/.f64 t (+.f64 t x)) a))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (/.f64 (neg.f64 t) (+.f64 t x)) a (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (/.f64 (neg.f64 t) (+.f64 t x)) a (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 t x)) (/.f64 (*.f64 a t) (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (*.f64 a (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64))))) y (-.f64 (/.f64 (*.f64 a t) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 a (*.f64 (+.f64 t x) (+.f64 t x)))))) y)) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (neg.f64 t) (+.f64 t x)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 t (+.f64 t x)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x)))))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 t) (+.f64 t x)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 t x)) (/.f64 t (*.f64 (+.f64 t x) (+.f64 t x))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 t (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 t (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x))))) y)) y)))
#s(approx (- (neg t) y) (neg.f64 t))
#s(approx (- (neg t) y) (-.f64 (neg.f64 y) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 (-.f64 (+.f64 (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x)))) y (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (fma.f64 y (+.f64 (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (fma.f64 a t (*.f64 z x)) (pow.f64 (+.f64 t x) #s(literal 4 binary64)))) y (/.f64 b (*.f64 (+.f64 t x) (+.f64 t x)))) (-.f64 (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 (+.f64 a z) (*.f64 (+.f64 t x) (+.f64 t x))))) (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x))))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (fma.f64 (/.f64 (-.f64 a b) x) y (/.f64 (*.f64 (-.f64 a z) t) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 z (-.f64 b (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (neg.f64 a)) (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y)) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 y y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (neg.f64 a)) (/.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 y y) y))) (+.f64 (/.f64 (fma.f64 (neg.f64 a) (-.f64 (-.f64 t t) x) (*.f64 (+.f64 t x) z)) y) (/.f64 (*.f64 (+.f64 t x) (fma.f64 a (-.f64 (-.f64 t t) x) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (+.f64 z (fma.f64 b (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 t x) y)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (/.f64 (fma.f64 (+.f64 t x) b (*.f64 z x)) y)))) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z (-.f64 b (fma.f64 (neg.f64 b) (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y y)) (fma.f64 b (+.f64 (/.f64 (+.f64 t x) y) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (*.f64 z x) y))))) (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 z (-.f64 (-.f64 x t) x)) (fma.f64 (*.f64 (+.f64 t x) z) (*.f64 y y) (*.f64 y (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x))))) (*.f64 (*.f64 y y) y))))
#s(approx (/ y (+ (+ t y) x)) #s(literal 1 binary64))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)))
#s(approx (/ y (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 y (+.f64 t x))) (*.f64 y y))))
#s(approx (/ y (+ (+ t y) x)) (-.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (+.f64 t x) y) #s(literal 3 binary64))) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (+ (+ t y) x) y)
#s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t x) y)) y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) y)
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) x) y)) y))
#s(approx (+ 1 (/ (+ t y) x)) (/.f64 y x))
#s(approx (+ 1 (/ (+ t y) x)) (*.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) y)) y))
#s(approx (/ (+ t y) x) (/.f64 y x))
#s(approx (/ (+ t y) x) (+.f64 (/.f64 y x) (*.f64 (/.f64 t (*.f64 x y)) y)))
#s(approx (+ t y) y)
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 t y)) y))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (*.f64 y y)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 (+.f64 z (fma.f64 x (/.f64 z y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y)))) (fma.f64 z (/.f64 (+.f64 t x) y) (/.f64 (*.f64 (*.f64 z (-.f64 (-.f64 x t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 t x) t) (*.f64 y y))) (/.f64 t y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (fma.f64 t (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (*.f64 (*.f64 y y) y)) (fma.f64 (neg.f64 t) (/.f64 (+.f64 t x) (*.f64 y y)) (/.f64 t y)))))
#s(approx (+ y x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x y)) y))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (*.f64 (*.f64 y y) y)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x)) (*.f64 y y))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x y) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (/.f64 x y) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 t x) (*.f64 y y)) (-.f64 (+.f64 (/.f64 x y) (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) x) (*.f64 (*.f64 y y) y))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (neg.f64 y))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64)) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 a (+.f64 z (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a z) (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y)) (/.f64 (fma.f64 a t (*.f64 z x)) y))) b) (*.f64 (+.f64 t x) (/.f64 (-.f64 (+.f64 a z) b) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 (+.f64 a z) (-.f64 (+.f64 (/.f64 (fma.f64 a t (*.f64 z x)) y) (/.f64 (*.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 (+.f64 t x) (+.f64 t x))) (*.f64 (*.f64 y y) y))) b)) (*.f64 (+.f64 t x) (+.f64 (/.f64 (-.f64 (+.f64 a z) b) y) (/.f64 (-.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (-.f64 (+.f64 a z) b) (+.f64 t x))) (*.f64 y y))))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (-.f64 (/.f64 (+.f64 z (*.f64 (/.f64 t x) a)) y) (/.f64 b x))) (*.f64 t (/.f64 z (*.f64 x y)))) y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (fma.f64 (neg.f64 x) z (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (*.f64 (neg.f64 (+.f64 t x)) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 (-.f64 z b) (/.f64 (-.f64 (+.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (+.f64 t x) (/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (-.f64 (*.f64 a (-.f64 (-.f64 t t) x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y))) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) a)) (*.f64 (+.f64 t x) z)) (fma.f64 a t (*.f64 (+.f64 t x) b))) y)) a))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (*.f64 (neg.f64 x) z) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (fma.f64 (neg.f64 x) z (-.f64 (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b))))) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 (-.f64 z b) (/.f64 (-.f64 (neg.f64 (fma.f64 z x (/.f64 (-.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (neg.f64 (*.f64 z (-.f64 (-.f64 x t) x))) (*.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) b)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) b)) y))) (*.f64 (+.f64 t x) (neg.f64 (-.f64 z b)))) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) y)))
#s(approx (/ y (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x)) y) (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x)))) y) (+.f64 t x)) y)))
#s(approx (+ (+ t y) x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 (+.f64 t x)) y) #s(literal 1 binary64))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (neg.f64 y) (-.f64 (*.f64 (neg.f64 x) (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 t x)) y)) #s(literal 1 binary64))))
#s(approx (+ 1 (/ (+ t y) x)) (*.f64 (neg.f64 (-.f64 (/.f64 (+.f64 #s(literal -1 binary64) (/.f64 (neg.f64 t) x)) y) (/.f64 #s(literal 1 binary64) x))) y))
#s(approx (/ (+ t y) x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 t) (*.f64 x y)) (/.f64 #s(literal 1 binary64) x))))
#s(approx (+ t y) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 t) y) #s(literal 1 binary64))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (fma.f64 (neg.f64 x) z (fma.f64 (+.f64 t x) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y) (*.f64 (+.f64 t x) z))) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (/.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 z (-.f64 (-.f64 x t) x)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 z (-.f64 (-.f64 x t) x)))) y))) (*.f64 (+.f64 t x) z)) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 x) (-.f64 (*.f64 (+.f64 t x) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y)) (+.f64 t x))) y)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (neg.f64 (*.f64 (+.f64 t x) (+.f64 t x))) (/.f64 (neg.f64 (-.f64 (-.f64 x t) x)) y) (*.f64 (neg.f64 (-.f64 (-.f64 x t) x)) (+.f64 t x))) y) (+.f64 t x))) y)))
#s(approx (+ y x) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 x) y) #s(literal 1 binary64))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (neg.f64 (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (*.f64 a (-.f64 (-.f64 t t) x)) y) (*.f64 (neg.f64 (+.f64 t x)) (*.f64 a (-.f64 (-.f64 t t) x)))) y) (*.f64 a (-.f64 (-.f64 t t) x))) y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 t x) y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (-.f64 (/.f64 (*.f64 (+.f64 t x) (+.f64 t x)) y) t) x)) (neg.f64 y)) x) (neg.f64 y)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (neg.f64 y) (+.f64 #s(literal 1 binary64) (/.f64 t y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (fma.f64 (+.f64 t x) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x)))) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (neg.f64 (-.f64 (neg.f64 a) (-.f64 z b))) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (fma.f64 z x (/.f64 (fma.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (/.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) (neg.f64 y)) (*.f64 (-.f64 (neg.f64 (fma.f64 a t (*.f64 z x))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) (+.f64 t x))) y)))) (*.f64 (-.f64 (neg.f64 a) (-.f64 z b)) (+.f64 t x))) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)) y)) (/.f64 z x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 (+.f64 t x) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t x) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 (+.f64 t x) y)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx z z)
#s(approx (- z (- b a)) (-.f64 a b))
#s(approx (- z (- b a)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (+.f64 (+.f64 t x) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (-.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 y b)) (+.f64 (+.f64 t x) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (fma.f64 (neg.f64 b) (/.f64 y x) (fma.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z (*.f64 (/.f64 (+.f64 t y) x) a))))
#s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))
#s(approx (/ (* (- a z) t) x) (/.f64 (*.f64 #s(literal -1 binary64) (*.f64 t (-.f64 z a))) x))
#s(approx (* (- a z) t) (*.f64 a t))
#s(approx (* (- a z) t) (*.f64 #s(literal -1 binary64) (*.f64 t (-.f64 z a))))
#s(approx (- a z) a)
#s(approx (- a z) (-.f64 a z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 (+.f64 t x) y) z)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (*.f64 a (+.f64 t y)) z)) (+.f64 (+.f64 t x) y))) z))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 (+.f64 t x) y) z)) (/.f64 (+.f64 x y) (+.f64 (+.f64 t x) y))) z))
#s(approx (- z (- b a)) z)
#s(approx (- z (- b a)) (+.f64 z (*.f64 z (/.f64 (-.f64 a b) z))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 (+.f64 t x) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 (+.f64 t x) y) z))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) (*.f64 z x))) (/.f64 t x)) z))
#s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 (neg.f64 t) x) z))
#s(approx (/ (* (- a z) t) x) (*.f64 (+.f64 (/.f64 (neg.f64 t) x) (*.f64 a (/.f64 t (*.f64 z x)))) z))
#s(approx (* (- a z) t) (*.f64 (neg.f64 t) z))
#s(approx (* (- a z) t) (*.f64 (+.f64 (neg.f64 t) (/.f64 (*.f64 a t) z)) z))
#s(approx (- a z) (neg.f64 z))
#s(approx (- a z) (*.f64 (-.f64 (/.f64 a z) #s(literal 1 binary64)) z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 x (/.f64 (*.f64 a t) z)) (+.f64 t x)) z))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 x (/.f64 (*.f64 a t) z)) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 (+.f64 x y)) (+.f64 (+.f64 t x) y)) (/.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) (+.f64 (+.f64 t x) y)) z))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (*.f64 (+.f64 x y) z) (+.f64 (+.f64 t x) y)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 z) (/.f64 (+.f64 (neg.f64 (+.f64 x y)) (/.f64 (*.f64 y b) z)) (+.f64 (+.f64 t x) y))))
#s(approx (- z (- b a)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (-.f64 a b) (neg.f64 z)) #s(literal 1 binary64))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 (+.f64 x y)) (+.f64 (+.f64 t x) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 (+.f64 t x) y) z)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (-.f64 (/.f64 (neg.f64 y) x) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))) z))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 z) (-.f64 (-.f64 (/.f64 (neg.f64 y) x) (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) (*.f64 z x))) (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)))))
#s(approx (/ (* (- a z) t) x) (*.f64 (neg.f64 z) (fma.f64 (neg.f64 a) (/.f64 t (*.f64 z x)) (/.f64 t x))))
#s(approx (* (- a z) t) (*.f64 (neg.f64 z) (-.f64 t (/.f64 (*.f64 a t) z))))
#s(approx (- a z) (*.f64 (neg.f64 z) (-.f64 #s(literal 1 binary64) (/.f64 a z))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (neg.f64 z) (neg.f64 (/.f64 (+.f64 x (/.f64 (*.f64 a t) z)) (+.f64 t x)))))
#s(approx (+ (* a t) (* z x)) (*.f64 (neg.f64 z) (-.f64 (neg.f64 x) (/.f64 (*.f64 a t) z))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 (neg.f64 y) b) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 (neg.f64 y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))))) t (-.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))) (fma.f64 (-.f64 (-.f64 (fma.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (*.f64 (-.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (neg.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t) (neg.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (-.f64 (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))))))) t (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (/.f64 z (+.f64 x y))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (fma.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y)))) t))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (-.f64 z (-.f64 (*.f64 b (/.f64 y (+.f64 x y))) (*.f64 (fma.f64 t (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (fma.f64 (-.f64 (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))))) (-.f64 (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 z (+.f64 x y)))) t))))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y (+.f64 x y)))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (neg.f64 t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 (-.f64 (/.f64 (*.f64 t y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y))))
#s(approx (/ y (+ (+ t y) x)) (fma.f64 t (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))) (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 y (+.f64 x y))))
#s(approx (+ (+ t y) x) (+.f64 x y))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) x))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (+.f64 t (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) x)))
#s(approx (+ 1 (/ (+ t y) x)) (+.f64 #s(literal 1 binary64) (/.f64 y x)))
#s(approx t t)
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (-.f64 z (*.f64 t (/.f64 z (+.f64 x y)))))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 t (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (+.f64 z (*.f64 (-.f64 (*.f64 (fma.f64 (neg.f64 t) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y)))) t) (/.f64 z (+.f64 x y))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (-.f64 #s(literal 1 binary64) (/.f64 t (+.f64 x y))))
#s(approx (/ (+ y x) (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (*.f64 (-.f64 (/.f64 t (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (+.f64 x y))) t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (+.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (/.f64 (neg.f64 t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) t (-.f64 (/.f64 t (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (+.f64 x y)))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (neg.f64 a) (/.f64 y (+.f64 x y))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 (fma.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 y (+.f64 x y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (fma.f64 (neg.f64 a) (/.f64 y (+.f64 x y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (-.f64 (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))))) t)) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (/.f64 (neg.f64 y) (+.f64 x y)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (neg.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))) t (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 y) (+.f64 x y)) (*.f64 (neg.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y)))))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (+.f64 (/.f64 (neg.f64 y) (+.f64 x y)) (*.f64 (+.f64 (neg.f64 (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (/.f64 y (*.f64 (+.f64 x y) (+.f64 x y))))) (*.f64 (neg.f64 (-.f64 (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64)))) t (/.f64 y (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x y) (+.f64 x y))))) t)) t)))
#s(approx (- (neg t) y) (-.f64 (neg.f64 t) y))
#s(approx (neg t) (neg.f64 t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 x y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (-.f64 (*.f64 a (/.f64 y (+.f64 x y))) (*.f64 b (/.f64 y (+.f64 x y)))))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (-.f64 (-.f64 (+.f64 (/.f64 a (+.f64 x y)) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y))))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 z (fma.f64 (-.f64 (-.f64 (+.f64 (fma.f64 (-.f64 (-.f64 (fma.f64 (-.f64 (-.f64 (+.f64 (/.f64 a (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (*.f64 b (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) (/.f64 z (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (*.f64 a (/.f64 y (pow.f64 (+.f64 x y) #s(literal 4 binary64))))) t (+.f64 (/.f64 z (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))))) (/.f64 a (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 (*.f64 y b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) t (/.f64 a (+.f64 x y))) (/.f64 (*.f64 y b) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 z (+.f64 x y))) (/.f64 (*.f64 a y) (*.f64 (+.f64 x y) (+.f64 x y)))) t (*.f64 a (/.f64 y (+.f64 x y))))) (*.f64 b (/.f64 y (+.f64 x y)))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (*.f64 y (-.f64 (+.f64 a z) b)) (*.f64 z y)) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (-.f64 (+.f64 z (/.f64 (fma.f64 (-.f64 a z) t (*.f64 y (-.f64 (+.f64 a z) b))) x)) (/.f64 (*.f64 z y) x)))
#s(approx (* (- a z) t) (*.f64 (-.f64 a z) t))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (fma.f64 (/.f64 (-.f64 z a) (*.f64 x x)) t (/.f64 (-.f64 a z) x)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 z (*.f64 (fma.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 (*.f64 x x) x)) t (/.f64 (-.f64 z a) (*.f64 x x))) t (/.f64 (-.f64 a z) x)) t)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) a)
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (fma.f64 b (/.f64 (*.f64 (+.f64 x y) y) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) z) t))) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t))) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 (-.f64 (-.f64 (fma.f64 (neg.f64 b) (/.f64 y t) (/.f64 (fma.f64 (*.f64 (neg.f64 y) (*.f64 (+.f64 x y) (+.f64 x y))) b (fma.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t (*.f64 (*.f64 t t) (*.f64 (+.f64 x y) z)))) (*.f64 (*.f64 t t) t))) (neg.f64 a)) (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))) z (*.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)))) (*.f64 (*.f64 t t) t))) (+.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (neg.f64 t)) (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y))) (*.f64 t t)))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (-.f64 (fma.f64 (+.f64 x y) z (/.f64 (*.f64 (*.f64 (+.f64 x y) y) b) t)) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t)))) t))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 y b (/.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 t t)))) (-.f64 (fma.f64 (+.f64 x y) z (*.f64 b (fma.f64 y (/.f64 (+.f64 x y) t) (*.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (*.f64 z (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t))))))) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 y t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (fma.f64 y (pow.f64 (/.f64 (+.f64 x y) t) #s(literal 3 binary64)) (fma.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (+.f64 x y) y) t)))) t))
#s(approx (+ (+ t y) x) t)
#s(approx (+ (+ t y) x) (+.f64 t (*.f64 t (/.f64 (+.f64 x y) t))))
#s(approx (* (+ 1 (/ (+ t y) x)) x) t)
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) x) t)) t))
#s(approx (+ 1 (/ (+ t y) x)) (/.f64 t x))
#s(approx (+ 1 (/ (+ t y) x)) (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) x) t)))
#s(approx (/ (+ t y) x) (*.f64 (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) x) t))
#s(approx (+ t y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (*.f64 (+.f64 x y) z) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 z) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (*.f64 (+.f64 x y) z)) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 z (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t))) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (-.f64 (fma.f64 (neg.f64 z) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t)) (*.f64 (+.f64 x y) z)) (fma.f64 (neg.f64 z) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t))) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 x y) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 x y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (-.f64 (-.f64 (+.f64 x y) (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) (*.f64 (*.f64 t t) t))) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) (*.f64 (neg.f64 t) t))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (-.f64 (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t)))))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (+.f64 (+.f64 (neg.f64 a) (neg.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (*.f64 (*.f64 t t) t)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t)))) (/.f64 (*.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y)) (*.f64 t t))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 x t) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (/.f64 x t) #s(literal 1 binary64))))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (fma.f64 (neg.f64 x) (/.f64 (+.f64 x y) (*.f64 t t)) (-.f64 (+.f64 (/.f64 x t) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) x) (*.f64 (*.f64 t t) t))) #s(literal 1 binary64))))
#s(approx (- (neg t) y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (neg.f64 (+.f64 x y)) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 t t)) (/.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) t))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (-.f64 (+.f64 (+.f64 a (/.f64 (fma.f64 a y (*.f64 (+.f64 x y) z)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (*.f64 t t) t))) (/.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) t)) (/.f64 (*.f64 (-.f64 (*.f64 a y) (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b))) (+.f64 x y)) (*.f64 t t))))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 a x) (+.f64 (/.f64 z t) (/.f64 (*.f64 y (-.f64 (+.f64 a z) b)) (*.f64 x t)))) (*.f64 (+.f64 (/.f64 y t) #s(literal 1 binary64)) (/.f64 z x))) t))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 x (-.f64 z a)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (fma.f64 (neg.f64 x) (/.f64 (*.f64 x (-.f64 z a)) (*.f64 t t)) (/.f64 (*.f64 x (-.f64 z a)) t))))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 (+.f64 a (fma.f64 x (/.f64 z t) (/.f64 (*.f64 (*.f64 x (-.f64 z a)) (*.f64 x x)) (*.f64 (*.f64 t t) t)))) (fma.f64 a (/.f64 x t) (*.f64 x (/.f64 (*.f64 x (-.f64 z a)) (*.f64 t t))))))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 a (*.f64 x (/.f64 z t))) t))
#s(approx (+ t x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 x t)) t))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (-.f64 (fma.f64 (+.f64 x y) (+.f64 (neg.f64 z) a) (*.f64 y b)) (*.f64 a y)) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (fma.f64 (neg.f64 (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (-.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) (*.f64 a y))) t) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (neg.f64 (-.f64 (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (neg.f64 (fma.f64 (*.f64 a (-.f64 (-.f64 y x) y)) (+.f64 x y) (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)) (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z))) t))) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (-.f64 (fma.f64 (+.f64 x y) a (*.f64 y b)) (*.f64 a y))) t) a)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 (neg.f64 z) (+.f64 x y) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)) (neg.f64 t)) (*.f64 (*.f64 (+.f64 x y) y) b)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (+.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) y) b) (*.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) z)) t) (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) y) b) (*.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) z)))) t) (-.f64 (*.f64 (*.f64 (+.f64 x y) y) b) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z))) t))) (*.f64 y b)) (neg.f64 t)))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 y (/.f64 (*.f64 (+.f64 x y) y) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (+.f64 y (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) t)) t))
#s(approx (/ y (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 y) (/.f64 (-.f64 (/.f64 (*.f64 y (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 t)) (*.f64 (+.f64 x y) y)) t)) (neg.f64 t)))
#s(approx (+ (+ t y) x) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 x y)) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (* (+ 1 (/ (+ t y) x)) x) (*.f64 (-.f64 (*.f64 (neg.f64 x) (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) t)) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ 1 (/ (+ t y) x)) (*.f64 (neg.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x))) t))
#s(approx (/ (+ t y) x) (*.f64 (-.f64 (/.f64 (neg.f64 y) (*.f64 x t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t)))
#s(approx (+ t y) (*.f64 (-.f64 (/.f64 (neg.f64 y) t) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (neg.f64 z) (+.f64 x y) (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z) t)) (neg.f64 t)))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 z (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t))) t))
#s(approx (* (/ (+ y x) (+ (+ t y) x)) z) (/.f64 (neg.f64 (fma.f64 (+.f64 x y) z (/.f64 (-.f64 (/.f64 (*.f64 z (-.f64 (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)))) (neg.f64 t)) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) z)) t))) (neg.f64 t)))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (+.f64 x y) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y)) t) (*.f64 (+.f64 x y) (+.f64 x y))) t)) t))
#s(approx (/ (+ y x) (+ (+ t y) x)) (/.f64 (-.f64 (neg.f64 (+.f64 x y)) (/.f64 (-.f64 (/.f64 (-.f64 (/.f64 (pow.f64 (+.f64 x y) #s(literal 4 binary64)) t) (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x y))) (neg.f64 t)) (*.f64 (+.f64 x y) (+.f64 x y))) t)) (neg.f64 t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (fma.f64 (neg.f64 (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (-.f64 (neg.f64 a) (/.f64 (+.f64 (/.f64 (fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 (*.f64 a (-.f64 (-.f64 y x) y)) t) (*.f64 (neg.f64 (+.f64 x y)) (*.f64 a (-.f64 (-.f64 y x) y)))) t) (*.f64 a (-.f64 (-.f64 y x) y))) t)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (*.f64 x (/.f64 (+.f64 x y) t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ (- (neg t) y) (+ (+ t y) x)) (-.f64 (/.f64 (-.f64 (/.f64 (*.f64 x (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) t) (+.f64 x y))) (neg.f64 t)) x) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- (neg t) y) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 y t)) (neg.f64 t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (*.f64 (+.f64 x y) (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t)) (*.f64 (+.f64 x y) a))) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 a (/.f64 (-.f64 (neg.f64 (fma.f64 a y (fma.f64 z x (*.f64 (-.f64 z b) y)))) (-.f64 (/.f64 (fma.f64 (*.f64 (neg.f64 (+.f64 x y)) (+.f64 x y)) (/.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) t) (*.f64 (neg.f64 (fma.f64 a y (-.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 x y) a)))) (+.f64 x y))) t) (*.f64 (+.f64 x y) a))) t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (/.f64 (-.f64 a z) x)) (neg.f64 t)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (neg.f64 a) x) (-.f64 (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 y (-.f64 (+.f64 a z) b)) (*.f64 z y)) x)) t) (/.f64 z x))) (neg.f64 t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (/.f64 (*.f64 x (-.f64 z a)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 a (/.f64 (+.f64 (neg.f64 (*.f64 x (+.f64 z (/.f64 (neg.f64 (*.f64 x (-.f64 z a))) t)))) (*.f64 a x)) t)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (-.f64 a (/.f64 (+.f64 (neg.f64 (fma.f64 z x (/.f64 (fma.f64 (*.f64 x x) (/.f64 (*.f64 x (-.f64 z a)) t) (*.f64 (neg.f64 x) (*.f64 x (-.f64 z a)))) t))) (*.f64 a x)) t)))
#s(approx (+ (* a t) (* z x)) (*.f64 (-.f64 (neg.f64 a) (*.f64 x (/.f64 z t))) (neg.f64 t)))
#s(approx (+ t x) (*.f64 (-.f64 (/.f64 x (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z))) (+.f64 (+.f64 t x) y)))
#s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (*.f64 (/.f64 (+.f64 t y) (+.f64 (+.f64 t x) y)) (neg.f64 a)))
#s(approx a a)
#s(approx (- z (- b a)) (-.f64 z b))
#s(approx (- b a) b)
#s(approx (- b a) (-.f64 b a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (+.f64 (+.f64 t x) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (fma.f64 z x (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 t x) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 (-.f64 z b) y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (- a z) (-.f64 a z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 (+.f64 t x) y) a)) (/.f64 (+.f64 t y) (+.f64 (+.f64 t x) y))) a))
#s(approx (- z (- b a)) a)
#s(approx (- z (- b a)) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (-.f64 z b) a)) a))
#s(approx (- b a) (neg.f64 a))
#s(approx (- b a) (*.f64 (-.f64 (/.f64 b a) #s(literal 1 binary64)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 (+.f64 t x) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 t y) (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 (+.f64 t x) y) a))) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 t y) x) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)) a)) a))
#s(approx (/ (* (- a z) t) x) (*.f64 (fma.f64 (neg.f64 t) (/.f64 z (*.f64 a x)) (/.f64 t x)) a))
#s(approx (* (- a z) t) (*.f64 (-.f64 t (*.f64 t (/.f64 z a))) a))
#s(approx (- a z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 z a)) a))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a))
#s(approx (+ (* a t) (* z x)) (*.f64 (+.f64 t (*.f64 x (/.f64 z a))) a))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (*.f64 a (+.f64 t y)) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 (+.f64 t x) y) a))) (/.f64 (+.f64 t y) (+.f64 (+.f64 t x) y))) (neg.f64 a)))
#s(approx (- z (- b a)) (*.f64 (-.f64 (/.f64 (-.f64 z b) (neg.f64 a)) #s(literal 1 binary64)) (neg.f64 a)))
#s(approx (- b a) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 b a)) (neg.f64 a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 t y)) (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 z x (*.f64 (-.f64 z b) y)) (*.f64 (+.f64 (+.f64 t x) y) a))) (neg.f64 a)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (/.f64 (+.f64 t y) (neg.f64 x)) (/.f64 (+.f64 z (/.f64 (-.f64 (*.f64 (-.f64 z b) y) (*.f64 z (+.f64 t y))) x)) a)) (neg.f64 a)))
#s(approx (/ (* (- a z) t) x) (*.f64 (neg.f64 (/.f64 (*.f64 t (+.f64 #s(literal -1 binary64) (/.f64 z a))) x)) a))
#s(approx (* (- a z) t) (*.f64 (*.f64 t (+.f64 #s(literal -1 binary64) (/.f64 z a))) (neg.f64 a)))
#s(approx (- a z) (*.f64 (-.f64 (/.f64 z a) #s(literal 1 binary64)) (neg.f64 a)))
#s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (neg.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x))) (neg.f64 a)))
#s(approx (+ (* a t) (* z x)) (*.f64 (-.f64 (neg.f64 t) (*.f64 x (/.f64 z a))) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 (+.f64 t x) y)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (+.f64 (+.f64 t x) y))))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (/.f64 (fma.f64 y (neg.f64 b) (*.f64 (+.f64 x y) z)) (+.f64 (+.f64 t x) y)))
#s(approx (neg b) (neg.f64 b))
#s(approx b b)
#s(approx (- z (- b a)) (+.f64 a z))
#s(approx (- z (- b a)) (-.f64 (+.f64 a z) b))
#s(approx (- b a) (-.f64 b a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (+.f64 (+.f64 t x) y)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 (neg.f64 y) b (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z))) (+.f64 (+.f64 t x) y)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 z y)) (*.f64 z (+.f64 t y))) x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (+.f64 z (+.f64 (/.f64 (fma.f64 (neg.f64 y) b (*.f64 a (+.f64 t y))) x) (/.f64 (*.f64 z (-.f64 (-.f64 y t) y)) x))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t x) y))))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 (+.f64 (+.f64 t x) y) b))) b))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (/.f64 (+.f64 (neg.f64 y) (/.f64 (*.f64 (+.f64 x y) z) b)) (+.f64 (+.f64 t x) y)) b))
#s(approx (- z (- b a)) (neg.f64 b))
#s(approx (- z (- b a)) (*.f64 (-.f64 (/.f64 (+.f64 a z) b) #s(literal 1 binary64)) b))
#s(approx (- b a) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 a b)) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t x) y))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (neg.f64 y) (+.f64 (+.f64 t x) y)) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 (+.f64 t x) y) b))) b))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 (+.f64 (/.f64 (neg.f64 y) x) (+.f64 (/.f64 z b) (/.f64 (fma.f64 a (+.f64 t y) (*.f64 z y)) (*.f64 x b)))) (/.f64 (*.f64 z (+.f64 t y)) (*.f64 x b))) b))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (+.f64 x y) z (*.f64 a (+.f64 t y))) (*.f64 (+.f64 (+.f64 t x) y) b))) (/.f64 y (+.f64 (+.f64 t x) y))) (neg.f64 b)))
#s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 x y) (*.f64 (+.f64 (+.f64 t x) y) b)) (/.f64 y (+.f64 (+.f64 t x) y))) (neg.f64 b)))
#s(approx (- z (- b a)) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 a z) b)) (neg.f64 b)))
#s(approx (- b a) (*.f64 (-.f64 (/.f64 a b) #s(literal 1 binary64)) (neg.f64 b)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 a (+.f64 t y) (*.f64 (+.f64 x y) z)) (*.f64 (+.f64 (+.f64 t x) y) b))) (/.f64 y (+.f64 (+.f64 t x) y))) (neg.f64 b)))
#s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (+.f64 (/.f64 (+.f64 z (/.f64 (-.f64 (fma.f64 a (+.f64 t y) (*.f64 z y)) (*.f64 z (+.f64 t y))) x)) (neg.f64 b)) (/.f64 y x)) (neg.f64 b)))

eval236.0ms (1.6%)

Memory
-10.3MiB live, 78.3MiB allocated; 11ms collecting garbage
Compiler

Compiled 13 696 to 4 034 computations (70.5% saved)

prune138.0ms (0.9%)

Memory
9.5MiB live, 71.1MiB allocated; 6ms collecting garbage
Pruning

42 alts after pruning (37 fresh and 5 done)

PrunedKeptTotal
New60015615
Fresh92231
Picked325
Done033
Total61242654
Accuracy
100.0%
Counts
654 → 42
Alt Table
Click to see full alt table
StatusAccuracyProgram
11.9%
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
19.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
27.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
13.0%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
8.4%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
8.6%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
42.1%
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
67.7%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
71.9%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
33.0%
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) a))
58.2%
(-.f64 (fma.f64 (neg.f64 b) #s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
47.6%
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
✓40.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
24.3%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
✓22.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
4.0%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
23.2%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
27.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
29.8%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
34.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
63.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 (+.f64 t x) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 (+.f64 t x) y) z))) z))
26.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
26.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
46.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
28.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
32.2%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
11.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
6.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
11.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
25.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
13.1%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
9.6%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
7.4%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
✓29.7%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
✓31.9%
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
✓52.4%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
33.9%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
61.3%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 (+.f64 t x) y) z)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (*.f64 a (+.f64 t y)) z)) (+.f64 (+.f64 t x) y))) z))
37.8%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
47.7%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
14.4%
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
Compiler

Compiled 2 263 to 1 464 computations (35.3% saved)

regimes524.0ms (3.5%)

Memory
-14.2MiB live, 170.3MiB allocated; 23ms collecting garbage
Counts
80 → 1
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x)))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) t)) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) t)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) t)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) z) (+.f64 y x)) (neg.f64 z))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x)))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 (+.f64 t x) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 (+.f64 t x) y) z))) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) (+.f64 t (+.f64 x y)))) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 (+.f64 t x) y) z)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (*.f64 a (+.f64 t y)) z)) (+.f64 (+.f64 t x) y))) z))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (fma.f64 (-.f64 (/.f64 (-.f64 (+.f64 a z) b) (+.f64 t x)) (/.f64 (fma.f64 a t (*.f64 z x)) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x))))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 a (fma.f64 (fma.f64 b (/.f64 y (*.f64 (+.f64 t y) (+.f64 t y))) (-.f64 (/.f64 z (+.f64 t y)) (fma.f64 y (/.f64 z (*.f64 (+.f64 t y) (+.f64 t y))) (/.f64 a (+.f64 t y))))) x (/.f64 (*.f64 y (-.f64 z b)) (+.f64 t y)))))
(-.f64 (fma.f64 (neg.f64 b) #s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (neg.f64 b) #s(approx (/ y (+ (+ t y) x)) (*.f64 (fma.f64 (-.f64 (/.f64 y (*.f64 (*.f64 (+.f64 t x) (+.f64 t x)) (+.f64 t x))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 t x) (+.f64 t x)))) y (/.f64 #s(literal 1 binary64) (+.f64 t x))) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
Outputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
Calls

7 calls:

127.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
120.0ms
y
108.0ms
t
103.0ms
b
20.0ms
z
Results
AccuracySegmentsBranch
98.9%1(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
98.9%1x
98.9%1y
98.9%1z
98.9%1t
98.9%1a
98.9%1b
Compiler

Compiled 22 to 52 computations (-136.4% saved)

regimes707.0ms (4.7%)

Memory
12.7MiB live, 290.4MiB allocated; 45ms collecting garbage
Counts
74 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x)))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) t)) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) t)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) t)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (/.f64 (fma.f64 (-.f64 (neg.f64 t) y) a (*.f64 b y)) z) (+.f64 y x)) (neg.f64 z))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (neg.f64 y) (+.f64 (-.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 (*.f64 (-.f64 a z) t) (*.f64 x y))) (/.f64 z x)))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 t (+.f64 x y))) (/.f64 (-.f64 (*.f64 (+.f64 t y) a) (*.f64 y b)) (*.f64 (+.f64 t (+.f64 x y)) z))) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (+.f64 (/.f64 (+.f64 x y) (+.f64 (+.f64 t x) y)) (/.f64 (-.f64 (*.f64 a (+.f64 t y)) (*.f64 y b)) (*.f64 (+.f64 (+.f64 t x) y) z))) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 t (+.f64 x y)) z)) (/.f64 (+.f64 x (+.f64 y (/.f64 (*.f64 (+.f64 t y) a) z))) (+.f64 t (+.f64 x y)))) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (*.f64 (fma.f64 (neg.f64 b) (/.f64 y (*.f64 (+.f64 (+.f64 t x) y) z)) (/.f64 (+.f64 (+.f64 x y) (/.f64 (*.f64 a (+.f64 t y)) z)) (+.f64 (+.f64 t x) y))) z))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 t y) x)) x))) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
Outputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
Calls

7 calls:

139.0ms
t
126.0ms
x
125.0ms
z
119.0ms
y
91.0ms
a
Results
AccuracySegmentsBranch
85.9%1x
89.9%3z
90.7%3t
85.9%1a
95.4%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
85.9%1y
85.9%1b
Compiler

Compiled 22 to 52 computations (-136.4% saved)

regimes140.0ms (0.9%)

Memory
8.9MiB live, 55.3MiB allocated; 2ms collecting garbage
Counts
66 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x)))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 (-.f64 (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b))) (*.f64 (+.f64 t y) z)) x) z))
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 t (+.f64 x y))))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) t)) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) t)) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) t)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) (*.f64 (/.f64 (+.f64 y x) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) z)) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) #s(approx (+ (+ t y) x) #s(approx (* (+ 1 (/ (+ t y) x)) x) t))) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (+.f64 t y) (/.f64 (fma.f64 z x (*.f64 y (-.f64 z b))) a)) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (+.f64 t y) a (*.f64 (+.f64 y x) z)) b) (neg.f64 y)) (+.f64 (+.f64 t y) x)) b))
Outputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (-.f64 (+.f64 a z) b) y (fma.f64 a t (*.f64 z x)))) (+.f64 (+.f64 x t) y))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
Calls

2 calls:

120.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
17.0ms
t
Results
AccuracySegmentsBranch
76.6%4t
90.5%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 17 to 22 computations (-29.4% saved)

regimes318.0ms (2.1%)

Memory
-1.7MiB live, 141.6MiB allocated; 15ms collecting garbage
Counts
58 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 (-.f64 z b) y))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (+.f64 a (*.f64 (fma.f64 (/.f64 (-.f64 a z) (*.f64 t t)) x (/.f64 (-.f64 z a) t)) x))))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (*.f64 x (/.f64 z (+.f64 t x)))) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
Outputs
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 (+.f64 t y) a (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
Calls

6 calls:

105.0ms
b
87.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
78.0ms
x
15.0ms
z
15.0ms
y
Results
AccuracySegmentsBranch
78.2%3x
77.9%3y
76.1%4b
78.5%3a
75.0%4z
80.0%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 21 to 46 computations (-119% saved)

regimes305.0ms (2%)

Memory
-28.2MiB live, 118.7MiB allocated; 10ms collecting garbage
Counts
54 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (+.f64 z (/.f64 (-.f64 (*.f64 y (neg.f64 b)) (*.f64 (neg.f64 y) a)) (+.f64 x y))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) #s(approx (+ (* (- (+ a z) b) y) (+ (* a t) (* z x))) (fma.f64 a t (*.f64 (-.f64 a b) y)))) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (fma.f64 z x (*.f64 y (-.f64 z b)))) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 (+.f64 (/.f64 (-.f64 (neg.f64 a) (-.f64 z b)) x) (/.f64 z x))) y)))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 (+.f64 y x) z)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Outputs
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(-.f64 (fma.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x)) #s(approx (* (/ (+ y x) (+ (+ t y) x)) z) z)) #s(approx (* (/ (- (neg t) y) (+ (+ t y) x)) a) (neg.f64 a)))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
Calls

4 calls:

118.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
86.0ms
x
14.0ms
a
14.0ms
y
Results
AccuracySegmentsBranch
76.9%4y
77.2%3x
77.3%3a
77.0%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 19 to 34 computations (-78.9% saved)

regimes170.0ms (1.1%)

Memory
4.9MiB live, 193.4MiB allocated; 20ms collecting garbage
Counts
48 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 (+.f64 t (*.f64 x (/.f64 z a))) (+.f64 t x)) a)))
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 (+.f64 t y) x)) a))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Calls

7 calls:

49.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
42.0ms
t
15.0ms
x
13.0ms
a
12.0ms
b
Results
AccuracySegmentsBranch
70.8%5z
71.1%3b
65.0%2t
70.4%3y
68.3%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
69.7%3x
72.4%5a
Compiler

Compiled 22 to 52 computations (-136.4% saved)

regimes99.0ms (0.7%)

Memory
26.6MiB live, 222.7MiB allocated; 20ms collecting garbage
Counts
46 → 4
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 z x)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
Calls

6 calls:

28.0ms
y
17.0ms
a
14.0ms
x
14.0ms
z
12.0ms
b
Results
AccuracySegmentsBranch
63.9%5z
68.5%4(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
63.6%6a
67.7%4x
63.7%3y
60.3%4b
Compiler

Compiled 21 to 46 computations (-119% saved)

regimes30.0ms (0.2%)

Memory
16.0MiB live, 106.7MiB allocated; 7ms collecting garbage
Counts
44 → 4
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (-.f64 (+.f64 a z) b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
Calls

2 calls:

15.0ms
t
13.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Results
AccuracySegmentsBranch
62.5%5t
68.0%4(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 17 to 22 computations (-29.4% saved)

regimes46.0ms (0.3%)

Memory
-29.5MiB live, 101.2MiB allocated; 24ms collecting garbage
Counts
43 → 4
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
Outputs
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
(-.f64 #s(approx (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) z) (*.f64 (/.f64 (-.f64 (neg.f64 t) y) (+.f64 #s(approx (+ t y) y) x)) a))
Calls

2 calls:

20.0ms
x
10.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Results
AccuracySegmentsBranch
67.7%4x
66.1%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 17 to 22 computations (-29.4% saved)

regimes52.0ms (0.4%)

Memory
19.6MiB live, 119.5MiB allocated; 34ms collecting garbage
Counts
42 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (/.f64 (+.f64 y x) (+.f64 (+.f64 t y) x)) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 t y) a)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (+.f64 y x) z)) (+.f64 (+.f64 x t) y))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) (+.f64 t x)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
Calls

2 calls:

28.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
22.0ms
x
Results
AccuracySegmentsBranch
66.1%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
60.8%3x
Compiler

Compiled 17 to 22 computations (-29.4% saved)

regimes78.0ms (0.5%)

Memory
-0.5MiB live, 125.9MiB allocated; 32ms collecting garbage
Counts
38 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 a t)) (+.f64 (+.f64 x t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 z x)) (+.f64 (+.f64 x t) y))
(/.f64 (-.f64 #s(approx (+ (* (+ x y) z) (* (+ t y) a)) (*.f64 a t)) (*.f64 y b)) #s(approx (+ (+ x t) y) x))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (*.f64 (neg.f64 b) (/.f64 y (+.f64 (+.f64 t y) x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 (+.f64 x t) y))
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 (-.f64 a z) t)) x) z))
Calls

4 calls:

26.0ms
z
22.0ms
x
18.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
10.0ms
y
Results
AccuracySegmentsBranch
60.8%3x
52.4%1z
59.3%3y
59.4%4(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
Compiler

Compiled 19 to 34 computations (-78.9% saved)

regimes19.0ms (0.1%)

Memory
27.1MiB live, 27.1MiB allocated; 0ms collecting garbage
Counts
32 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) t) y))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) (+.f64 #s(approx (+ x t) x) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 (fma.f64 a t (*.f64 z x)) #s(approx (+ t x) x)))
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 (/.f64 #s(approx (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) (*.f64 y (neg.f64 b))) x) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
Calls

1 calls:

16.0ms
x
Results
AccuracySegmentsBranch
60.3%3x
Compiler

Compiled 1 to 6 computations (-500% saved)

regimes41.0ms (0.3%)

Memory
-11.2MiB live, 46.0MiB allocated; 18ms collecting garbage
Counts
27 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 x (+.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) (+.f64 t x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (+.f64 #s(approx (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) (*.f64 (/.f64 (neg.f64 t) x) z)) z))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (/ (+ (* a t) (* z x)) (+ t x)) (*.f64 (/.f64 t (+.f64 t x)) a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
Calls

3 calls:

24.0ms
x
7.0ms
t
7.0ms
y
Results
AccuracySegmentsBranch
59.3%3y
58.0%3t
59.1%3x
Compiler

Compiled 3 to 18 computations (-500% saved)

regimes43.0ms (0.3%)

Memory
-14.8MiB live, 80.2MiB allocated; 7ms collecting garbage
Counts
23 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (-.f64 (+.f64 a z) b))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) #s(approx (/ (* (- a z) t) x) (*.f64 (/.f64 t x) a))))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 #s(approx (- a z) a) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 a t)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) (/.f64 #s(approx (+ (* a t) (* z x)) (*.f64 z x)) #s(approx (+ t x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (neg.f64 b) (/.f64 y x))))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) t))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) x))
(/.f64 #s(approx (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (*.f64 (neg.f64 b) y)) #s(approx (+ (+ x t) y) y))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t x)) z)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (-.f64 a z) x) t)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a b) y) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (-.f64 a z) t) x)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (*.f64 (/.f64 (+.f64 t y) x) a)))
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) (/.f64 (*.f64 (+.f64 t y) a) x)))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z (-.f64 b a)))
Calls

6 calls:

9.0ms
x
8.0ms
t
6.0ms
a
6.0ms
b
6.0ms
y
Results
AccuracySegmentsBranch
56.3%3(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
57.3%3t
52.4%1b
54.3%2a
56.9%3x
57.6%3y
Compiler

Compiled 21 to 46 computations (-119% saved)

regimes19.0ms (0.1%)

Memory
-8.1MiB live, 38.6MiB allocated; 2ms collecting garbage
Counts
7 → 2
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) (-.f64 z #s(approx (- b a) b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
Outputs
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (-.f64 a b)))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (+.f64 a z)))
Calls

7 calls:

3.0ms
z
3.0ms
t
3.0ms
a
3.0ms
y
3.0ms
b
Results
AccuracySegmentsBranch
53.2%4z
52.2%2b
54.9%4a
47.7%1(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
54.7%4x
50.8%3t
49.5%2y
Compiler

Compiled 22 to 52 computations (-136.4% saved)

regimes10.0ms (0.1%)

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

4 calls:

2.0ms
a
2.0ms
b
2.0ms
x
2.0ms
z
Results
AccuracySegmentsBranch
49.7%3z
51.2%3x
51.7%5a
37.8%1b
Compiler

Compiled 4 to 24 computations (-500% saved)

regimes48.0ms (0.3%)

Memory
-22.1MiB live, 25.1MiB allocated; 41ms collecting garbage
Counts
4 → 3
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) #s(approx (+ (/ (- (+ (* (+ t y) a) (* y (- z b))) (* (+ t y) z)) x) z) z))
#s(approx (- (+ (* (neg b) (/ y (+ (+ t y) x))) (* (/ (+ y x) (+ (+ t y) x)) z)) (* (/ (- (neg t) y) (+ (+ t y) x)) a)) #s(approx (- z (- b a)) (neg.f64 b)))
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) z)
Calls

6 calls:

39.0ms
a
2.0ms
t
2.0ms
x
2.0ms
z
2.0ms
y
Results
AccuracySegmentsBranch
43.2%3a
44.8%3z
34.0%2(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
44.7%3t
37.7%4y
47.4%3x
Compiler

Compiled 21 to 46 computations (-119% saved)

regimes8.0ms (0.1%)

Memory
19.7MiB live, 19.7MiB allocated; 0ms collecting garbage
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
Outputs
#s(approx (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) a)
Calls

7 calls:

1.0ms
t
1.0ms
b
1.0ms
a
1.0ms
(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
1.0ms
y
Results
AccuracySegmentsBranch
31.9%1(/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y))
31.9%1y
31.9%1b
31.9%1a
31.9%1t
31.9%1z
31.9%1x
Compiler

Compiled 22 to 52 computations (-136.4% saved)

bsearch1.0ms (0%)

Memory
1.7MiB live, 1.7MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
4.326959053557305e+89
1.9418964226693207e+97
0.0ms
-inf
-4.537251000689128e+292
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch1.0ms (0%)

Memory
1.5MiB live, 1.5MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
1.934104478728521e+246
1.7283086834059794e+299
0.0ms
-inf
-4.537251000689128e+292
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch1.0ms (0%)

Memory
1.3MiB live, 1.3MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
3.823723997712434e+132
4.57567727734553e+140
0.0ms
-2.825899642745464e+125
-3.222757347820977e+124
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch40.0ms (0.3%)

Memory
1.5MiB live, 51.1MiB allocated; 7ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
14.0ms
1.1722756055752418e-29
2.3828597275147015e-23
22.0ms
-1.0250628335210187e+117
-9.130714931311627e+99
Samples
19.0ms304×0valid
Compiler

Compiled 993 to 956 computations (3.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 10.0ms
ival-add!: 4.0ms (41.6% of total)
ival-mult!: 4.0ms (41.6% of total)
ival-sub!: 1.0ms (10.4% of total)
ival-div!: 1.0ms (10.4% of total)
adjust: 0.0ms (0% of total)

bsearch30.0ms (0.2%)

Memory
8.2MiB live, 54.6MiB allocated; 4ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
12.0ms
5.771358315354112e+228
1.103937113558496e+232
14.0ms
-4.1930015092673626e+191
-7.467651320878109e+188
Samples
17.0ms256×0valid
Compiler

Compiled 744 to 745 computations (-0.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 10.0ms
ival-mult!: 5.0ms (51.9% of total)
ival-add!: 3.0ms (31.1% of total)
ival-sub!: 1.0ms (10.4% of total)
ival-div!: 1.0ms (10.4% of total)
adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory
1.7MiB live, 1.7MiB allocated; 0ms collecting garbage
Algorithm
3×left-value
Steps
TimeLeftRight
0.0ms
1.9418964226693207e+97
2.0426442647813903e+98
0.0ms
-1.410018605991488e-24
-1.7010025486219317e-26
0.0ms
-5.447937116191303e+144
-2.5503605460231342e+144
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch1.0ms (0%)

Memory
1.6MiB live, 1.6MiB allocated; 0ms collecting garbage
Algorithm
3×left-value
Steps
TimeLeftRight
0.0ms
1.9372044159710222e+178
3.835471671257342e+193
0.0ms
-3.2937506355629193e-6
-4.484937935124401e-9
0.0ms
-5.447937116191303e+144
-2.5503605460231342e+144
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch42.0ms (0.3%)

Memory
-21.1MiB live, 74.5MiB allocated; 7ms collecting garbage
Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
11.0ms
5.4767010808232104e-42
3.5013993225006486e-41
12.0ms
-5.5227619818459704e-36
-6.85489026253986e-40
14.0ms
-2.0496709179602763e+45
-3.2487952887630266e+40
Samples
23.0ms352×0valid
Compiler

Compiled 1 102 to 1 049 computations (4.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 13.0ms
ival-add!: 6.0ms (45.6% of total)
ival-mult!: 5.0ms (38% of total)
ival-div!: 2.0ms (15.2% of total)
ival-sub!: 1.0ms (7.6% of total)
adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory
1.5MiB live, 1.5MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
1.9372044159710222e+178
3.835471671257342e+193
0.0ms
-1.0982650690000735e+237
-7.157028969004562e+196
Compiler

Compiled 19 to 25 computations (-31.6% saved)

bsearch30.0ms (0.2%)

Memory
7.3MiB live, 53.7MiB allocated; 3ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
1.656759357678952e+33
2.9437712995883773e+38
11.0ms
-1.769025846176925e+159
-2.111592328064389e+157
Samples
17.0ms256×0valid
Compiler

Compiled 936 to 857 computations (8.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 9.0ms
ival-add!: 4.0ms (42.5% of total)
ival-mult!: 3.0ms (31.9% of total)
ival-sub!: 1.0ms (10.6% of total)
ival-div!: 1.0ms (10.6% of total)
adjust: 0.0ms (0% of total)

bsearch20.0ms (0.1%)

Memory
-10.8MiB live, 35.8MiB allocated; 2ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
17.0ms
1.1814065030312207e+51
6.97993031557326e+60
1.0ms
-1.769025846176925e+159
-2.111592328064389e+157
Samples
11.0ms160×0valid
Compiler

Compiled 953 to 899 computations (5.7% saved)

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

bsearch32.0ms (0.2%)

Memory
13.1MiB live, 59.7MiB allocated; 3ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
8.105853347479062e+23
7.109197817283557e+30
14.0ms
-2.9324180867919014e-115
-5.716161132339086e-121
Samples
18.0ms288×0valid
Compiler

Compiled 978 to 943 computations (3.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 10.0ms
ival-add!: 4.0ms (39.5% of total)
ival-mult!: 4.0ms (39.5% of total)
ival-sub!: 1.0ms (9.9% of total)
ival-div!: 1.0ms (9.9% of total)
adjust: 0.0ms (0% of total)

bsearch30.0ms (0.2%)

Memory
0.0MiB live, 48.4MiB allocated; 7ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
11.0ms
2.314229671929318e+44
2.000546902190595e+46
16.0ms
-103859.11913724538
-15.161553556675578
Samples
18.0ms240×0valid
Compiler

Compiled 864 to 775 computations (10.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 7.0ms
ival-add!: 3.0ms (40.3% of total)
ival-mult!: 3.0ms (40.3% of total)
ival-div!: 1.0ms (13.4% of total)
ival-sub!: 0.0ms (0% of total)
adjust: 0.0ms (0% of total)

bsearch12.0ms (0.1%)

Memory
20.4MiB live, 20.4MiB allocated; 0ms collecting garbage
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
11.0ms
-3.835471671257351e+193
-4.1930015092673626e+191
Samples
7.0ms112×0valid
Compiler

Compiled 430 to 389 computations (9.5% saved)

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

bsearch36.0ms (0.2%)

Memory
-32.4MiB live, 60.5MiB allocated; 7ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
16.0ms
2.1719444767313385e-40
2.918330716399832e-27
16.0ms
-3962241.509816031
-41.628002445630145
Samples
18.0ms304×0valid
Compiler

Compiled 898 to 861 computations (4.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 9.0ms
ival-mult!: 4.0ms (42.2% of total)
ival-add!: 3.0ms (31.6% of total)
ival-sub!: 1.0ms (10.5% of total)
ival-div!: 1.0ms (10.5% of total)
adjust: 0.0ms (0% of total)

bsearch10.0ms (0.1%)

Memory
18.9MiB live, 18.9MiB allocated; 0ms collecting garbage
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
1.0ms
2.1719444767313385e-40
2.918330716399832e-27
8.0ms
-8.858884807735875e+20
-2.923148144546051e+20
Samples
5.0ms80×0valid
Compiler

Compiled 534 to 565 computations (-5.8% saved)

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

derivations2.4s (16.3%)

Memory
-22.4MiB live, 1 034.3MiB allocated; 234ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 370 to 223 computations (39.7% saved)

preprocess182.0ms (1.2%)

Memory
56.4MiB live, 465.6MiB allocated; 74ms collecting garbage
Compiler

Compiled 386 to 239 computations (38.1% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...