Metrics for Data.Random.Distribution.Triangular:triangularCDF from random-fu-0.2.6.2, A

start0.0ms (0%)

Memory: 0.2MiB live, 0.2MiB allocated; 0ms collecting garbage

analyze212.0ms (3.2%)

Memory

-3.7MiB live, 289.9MiB allocated; 94ms collecting garbage

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.8%	0.2%	0%	0%	0%	0
0%	0%	99.8%	0.2%	0%	0%	0%	1
0%	0%	99.8%	0.2%	0%	0%	0%	2
0%	0%	99.8%	0.2%	0%	0%	0%	3
0%	0%	99.8%	0.2%	0%	0%	0%	4
25%	25%	74.9%	0.2%	0%	0%	0%	5
25%	25%	74.9%	0.2%	0%	0%	0%	6
25%	25%	74.9%	0.2%	0%	0%	0%	7
37.5%	37.4%	62.4%	0.2%	0%	0%	0%	8
56.3%	56.1%	43.7%	0.2%	0%	0%	0%	9
56.3%	56.1%	43.7%	0.2%	0%	0%	0%	10
56.3%	56.1%	43.7%	0.2%	0%	0%	0%	11
65.6%	65.5%	34.3%	0.2%	0%	0%	0%	12

Compiler

Compiled 13 to 12 computations (7.7% saved)

sample1.1s (16.4%)

Memory

39.5MiB live, 1 698.0MiB allocated; 281ms collecting garbage

Samples

672.0ms

8 256×

valid

Precisions

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

ival-sub: 128.0ms (36.4% of total)

ival-mult: 105.0ms (29.8% of total)

ival-div: 103.0ms (29.3% of total)

ival-true: 6.0ms (1.7% of total)

exact: 5.0ms (1.4% of total)

adjust: 3.0ms (0.9% of total)

ival-assert: 3.0ms (0.9% of total)

Bogosity

explain133.0ms (2%)

Memory

23.7MiB live, 201.4MiB allocated; 42ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
27	-	-	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
0	-	-	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
0	-	-	`t`
0	-	-	`#s(literal 1 binary64)`
0	-	-	`(*.f64 (-.f64 y z) (-.f64 y t))`
0	-	-	`(-.f64 y t)`
0	-	-	`z`
0	-	-	`y`
0	-	-	`(-.f64 y z)`
0	-	-	`x`

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	256

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

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

Precision?

0/0

Recall?

0/0

Samples

38.0ms

512×

valid

Compiler

Compiled 91 to 34 computations (62.6% saved)

Precisions

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

ival-sub: 8.0ms (39.7% of total)

ival-div: 7.0ms (34.8% of total)

ival-mult: 3.0ms (14.9% of total)

exact: 1.0ms (5% of total)

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

adjust: 0.0ms (0% of total)

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

preprocess261.0ms (3.9%)

Memory

-10.1MiB live, 280.3MiB allocated; 71ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	58	179
1	90	179
2	119	179
3	153	179
4	258	174
5	1034	174
6	2695	174
7	6549	174
0	10	11
0	15	11
1	20	11
2	25	11
3	35	11
4	68	11
5	269	11
6	2062	11
7	5341	11
0	8486	11

Stop Event

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

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))

Symmetry

(sort z t)

Compiler

Compiled 11 to 10 computations (9.1% saved)

eval0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 4 computations (-∞% saved)

prune0.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated; 0ms collecting garbage

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Compiler

Compiled 11 to 10 computations (9.1% saved)

simplify462.0ms (6.9%)

Memory

-7.2MiB live, 207.2MiB allocated; 96ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(-.f64 y z)
cost-diff	0	(*.f64 (-.f64 y z) (-.f64 y t))
cost-diff	0	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	38
0	15	38
1	20	38
2	25	38
3	35	38
4	68	38
5	269	38
6	2062	38
7	5341	38
0	8486	38

Stop Event

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

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
#s(literal 1 binary64)
(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
x
(*.f64 (-.f64 y z) (-.f64 y t))
(-.f64 y z)
y
z
(-.f64 y t)
t

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(literal 1 binary64)
(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
x
(*.f64 (-.f64 y z) (-.f64 y t))
(*.f64 (-.f64 y t) (-.f64 y z))
(-.f64 y z)
y
z
(-.f64 y t)
t

localize63.0ms (0.9%)

Memory

8.6MiB live, 54.9MiB allocated; 3ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.0	(-.f64 y t)
accuracy	0.0	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
accuracy	0.0234375	(*.f64 (-.f64 y z) (-.f64 y t))
accuracy	6.514129329070754	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))

Samples

56.0ms

256×

valid

Compiler

Compiled 40 to 12 computations (70% saved)

Precisions

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

ival-sub: 4.0ms (51.1% of total)

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

ival-mult: 2.0ms (25.5% of total)

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

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

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

series28.0ms (0.4%)

Memory

-14.0MiB live, 84.0MiB allocated; 16ms collecting garbage

Counts

5 → 100

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
(*.f64 (-.f64 y z) (-.f64 y t))
(-.f64 y z)
(-.f64 y t)

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Calls

12 calls:

Time	Variable		Point	Expression
5.0ms	z	@	0	((- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- y z) (- y t))
5.0ms	x	@	0	((- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- y z) (- y t))
2.0ms	t	@	0	((- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- y z) (- y t))
2.0ms	y	@	0	((- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- y z) (- y t))
2.0ms	y	@	-inf	((- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- y z) (- y t))

simplify180.0ms (2.7%)

Memory

-8.8MiB live, 311.6MiB allocated; 42ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	557	3114
1	1750	2860
2	7379	2791
0	8492	2725

Stop Event

1×	iter limit
1×	node limit

Counts

100 → 100

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y z)) (-.f64 y t))) x))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (*.f64 (neg.f64 x) (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y z)) (-.f64 y t)) (/.f64 #s(literal 1 binary64) x))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 t z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (/.f64 (.f64 (-.f64 (neg.f64 z) t) y) (.f64 t t)) (/.f64 x (.f64 z z)) (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (fma.f64 (neg.f64 y) (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (/.f64 x (pow.f64 (.f64 t z) #s(literal 3 binary64)))) (/.f64 (fma.f64 y x (.f64 (-.f64 (neg.f64 z) t) x)) (.f64 (.f64 (.f64 z z) t) t))) y (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 z) t) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64))) x (.f64 (.f64 (.f64 #s(literal 1 binary64) (+.f64 t z)) x) y)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (.f64 (neg.f64 y) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 (/.f64 (/.f64 x t) t) z) z)) (/.f64 (-.f64 (neg.f64 z) t) (.f64 t z))))) (/.f64 (/.f64 (/.f64 (/.f64 x t) t) z) z)) y)) y (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 t z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (neg.f64 (/.f64 (/.f64 x t) t)) (.f64 (/.f64 (-.f64 (neg.f64 z) t) z) (/.f64 y z)) (/.f64 x (.f64 t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 (/.f64 (/.f64 x t) t) z) z)) (.f64 (neg.f64 x) (/.f64 (/.f64 (/.f64 (-.f64 (neg.f64 z) t) z) z) (.f64 t t)))) y (/.f64 x (.f64 t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 z) t) (pow.f64 (.f64 t z) #s(literal 3 binary64))) x (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 (/.f64 (/.f64 x t) t) z) z)) (/.f64 (-.f64 (neg.f64 z) t) (.f64 t z)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 (/.f64 (/.f64 x t) t) z) z))) y (.f64 (neg.f64 (/.f64 (/.f64 x t) t)) (/.f64 (/.f64 (-.f64 (neg.f64 z) t) z) z))) y (/.f64 x (.f64 t z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) (*.f64 t z))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (-.f64 (neg.f64 z) t) y (*.f64 t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (-.f64 (-.f64 y t) z) y (*.f64 t z)))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) (neg.f64 z))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y z) (-.f64 y z))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) (neg.f64 t))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- y t) (-.f64 y t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (+.f64 t z) y) x x) (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 z) t) (pow.f64 y #s(literal 3 binary64))) x (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (pow.f64 y #s(literal 4 binary64)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (+.f64 t z) y) x x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 x (/.f64 (fma.f64 (neg.f64 x) (+.f64 t z) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y)) y)) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (-.f64 x (/.f64 (neg.f64 (fma.f64 (.f64 (-.f64 (neg.f64 z) t) t) (.f64 z x) (.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (-.f64 (neg.f64 z) t)))) (pow.f64 y #s(literal 3 binary64)))) (/.f64 (fma.f64 (neg.f64 x) (+.f64 t z) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y)) y)) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) (*.f64 y y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) (.f64 (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t z) y)) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (* (- y z) (- y t)) (.f64 (+.f64 (/.f64 (fma.f64 (/.f64 z y) t (-.f64 (neg.f64 z) t)) y) #s(literal 1 binary64)) (.f64 y y)))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) y)
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 z y)) y))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) y)
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- y t) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 t y)) y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (+.f64 t z) y) x x) (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 x (/.f64 (fma.f64 (neg.f64 x) (+.f64 t z) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y)) y)) (*.f64 y y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (+.f64 t z) y) x x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 x (/.f64 (fma.f64 (neg.f64 x) (+.f64 t z) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y)) y)) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 x (/.f64 (fma.f64 (neg.f64 x) (+.f64 t z) (/.f64 (-.f64 (/.f64 (fma.f64 (+.f64 t z) (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (.f64 (.f64 (.f64 (+.f64 t z) z) x) t)) (neg.f64 y)) (fma.f64 (neg.f64 x) (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (.f64 (.f64 z x) t))) (neg.f64 y))) y)) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (-.f64 #s(literal 1 binary64) (/.f64 (+.f64 t z) y)) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (.f64 (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 t (/.f64 (neg.f64 z) y) (+.f64 t z)) y)) y) y))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y z) (*.f64 (neg.f64 y) (-.f64 (/.f64 z y) #s(literal 1 binary64))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- y t) (*.f64 (neg.f64 y) (-.f64 (/.f64 t y) #s(literal 1 binary64))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 (fma.f64 z (/.f64 x y) x) y) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (/.f64 (/.f64 (+.f64 x (.f64 z (/.f64 x y))) (.f64 y y)) (neg.f64 (-.f64 y t))) z (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (fma.f64 (/.f64 (fma.f64 z (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (-.f64 y t))) z (/.f64 (neg.f64 x) (.f64 (.f64 (-.f64 y t) y) y))) z (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 z (/.f64 x y) x) y) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (/.f64 (/.f64 (+.f64 x (.f64 z (/.f64 x y))) (.f64 y y)) (-.f64 y t)) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) z (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (-.f64 y t)) z (/.f64 x (.f64 (.f64 (-.f64 y t) y) y))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) (-.f64 y z)))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- y z) (-.f64 y z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (fma.f64 y (/.f64 x z) x) (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 y x (/.f64 (.f64 (.f64 y x) y) z)) (*.f64 z z)) (/.f64 x z)) (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 (/.f64 x z) y x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) z) y) (-.f64 y t))) z)) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (/.f64 (fma.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)) x) (neg.f64 (-.f64 y t))) (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) z) y) (-.f64 y t))) z)) z))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 z) (-.f64 y t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- y z) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (neg.f64 x) (/.f64 (/.f64 y (-.f64 y t)) z)) (/.f64 x (-.f64 y t))) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) z) y) (-.f64 y t))) (neg.f64 z)) (/.f64 x (-.f64 y t))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 (/.f64 x z) y x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (/.f64 (fma.f64 (.f64 y y) (/.f64 x z) (.f64 y x)) z) (neg.f64 (-.f64 y t))) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 (.f64 y x) y (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) z)) (-.f64 y t)) (neg.f64 z)) (*.f64 y (/.f64 x (-.f64 y t)))) (neg.f64 z)) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y (fma.f64 (/.f64 (-.f64 y t) z) y t)) (neg.f64 z)))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- y z) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 y z)) (neg.f64 z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 (+.f64 (/.f64 (*.f64 t x) y) x) y) (-.f64 y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (/.f64 (/.f64 (+.f64 x (/.f64 (.f64 t x) y)) (.f64 y y)) (neg.f64 (-.f64 y z))) t (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (fma.f64 (/.f64 (fma.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (neg.f64 (-.f64 y z))) t (/.f64 (neg.f64 x) (.f64 (.f64 (-.f64 y z) y) y))) t (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (+.f64 (/.f64 (*.f64 t x) y) x) y) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (/.f64 (/.f64 (+.f64 x (/.f64 (.f64 t x) y)) (.f64 y y)) (-.f64 y z)) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 4 binary64))) x (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (-.f64 y z)) t (/.f64 x (.f64 (.f64 (-.f64 y z) y) y))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y z) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) (-.f64 y z)))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- y t) (-.f64 y t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (fma.f64 y (/.f64 x t) x) (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 y x (/.f64 (.f64 (.f64 y x) y) t)) (*.f64 t t)) (/.f64 x t)) (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 (/.f64 x t) y x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) t) y) (-.f64 y z))) t)) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (/.f64 (fma.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)) x) (neg.f64 (-.f64 y z))) (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) t) y) (-.f64 y z))) t)) t))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 t) (-.f64 y z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y z) t) y (neg.f64 (-.f64 y z))) t))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- y t) (*.f64 (-.f64 (/.f64 y t) #s(literal 1 binary64)) t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (neg.f64 x) (/.f64 (/.f64 y (-.f64 y z)) t)) (/.f64 x (-.f64 y z))) t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 (.f64 x (/.f64 (+.f64 (/.f64 (.f64 y y) t) y) (-.f64 y z))) (neg.f64 t)) (/.f64 x (-.f64 y z))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 (/.f64 x t) y x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (/.f64 (fma.f64 (.f64 y y) (/.f64 x t) (.f64 y x)) t) (neg.f64 (-.f64 y z))) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 (.f64 y x) y (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) t)) (-.f64 y z)) (neg.f64 t)) (*.f64 y (/.f64 x (-.f64 y z)))) (neg.f64 t)) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y (fma.f64 (/.f64 (-.f64 y z) t) y z)) (neg.f64 t)))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))
#s(approx (- y t) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 y t)) (neg.f64 t)))

rewrite226.0ms (3.4%)

Memory

22.7MiB live, 202.3MiB allocated; 58ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	33
0	15	33
1	178	33
2	2442	33
0	8067	33

Stop Event

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

Counts

5 → 224

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
(*.f64 (-.f64 y z) (-.f64 y t))
(-.f64 y z)
(-.f64 y t)

Outputs
(*.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (-.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(*.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)))
(*.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 #s(literal 3 binary64))) (sqrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 (cbrt.f64 #s(literal 3 binary64)) (cbrt.f64 #s(literal 3 binary64)))) (cbrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))
(/.f64 (+.f64 (sin.f64 (-.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (sin.f64 (+.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))) #s(literal 2 binary64))
(/.f64 (-.f64 (cos.f64 (-.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (cos.f64 (+.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))) #s(literal 2 binary64))
(/.f64 (+.f64 (cos.f64 (+.f64 (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (cos.f64 (-.f64 (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(-.f64 (pow.f64 (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(-.f64 (pow.f64 (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(-.f64 #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (cos.f64 (.f64 #s(literal 2 binary64) (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))))
(-.f64 #s(literal 1 binary64) (*.f64 (sin.f64 (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sin.f64 (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(exp.f64 (*.f64 (log.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 3 binary64) (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) #s(literal 1/3 binary64)))
(exp.f64 (*.f64 (log.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) #s(literal 3 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 (log.f64 (sqrt.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (log.f64 (sqrt.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(+.f64 (log.f64 (*.f64 (cbrt.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (cbrt.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))) (log.f64 (cbrt.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(+.f64 #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (cos.f64 (.f64 #s(literal 2 binary64) (asin.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y z)) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y z)) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(pow.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (sqrt.f64 #s(literal 3 binary64))) (sqrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (*.f64 (cbrt.f64 #s(literal 3 binary64)) (cbrt.f64 #s(literal 3 binary64)))) (cbrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(/.f64 (/.f64 x (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y z))) (-.f64 y t))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 x)) (.f64 (neg.f64 (-.f64 y z)) (-.f64 y t)))
(/.f64 (neg.f64 (/.f64 x (-.f64 y z))) (neg.f64 (-.f64 y t)))
(/.f64 (neg.f64 (neg.f64 x)) (neg.f64 (*.f64 (neg.f64 (-.f64 y z)) (-.f64 y t))))
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 (neg.f64 x) (*.f64 (neg.f64 (-.f64 y z)) (-.f64 y t)))
(/.f64 x (*.f64 (-.f64 y t) (-.f64 y z)))
(neg.f64 (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
(neg.f64 (/.f64 x (*.f64 (neg.f64 (-.f64 y z)) (-.f64 y t))))
(cbrt.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))) #s(literal 1/3 binary64)))
(exp.f64 (*.f64 (log.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 3 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(+.f64 (log.f64 (sqrt.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (log.f64 (sqrt.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 (log.f64 (*.f64 (cbrt.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (cbrt.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (log.f64 (cbrt.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (pow.f64 (exp.f64 (+.f64 t y)) (/.f64 (/.f64 x (-.f64 y z)) (*.f64 (+.f64 t y) (-.f64 y t)))))
(log.f64 (pow.f64 (.f64 (exp.f64 y) (exp.f64 t)) (/.f64 (/.f64 x (-.f64 y z)) (.f64 (+.f64 t y) (-.f64 y t)))))
(log.f64 (pow.f64 (exp.f64 (fma.f64 t (+.f64 t y) (*.f64 y y))) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))))
(log.f64 (pow.f64 (exp.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64)))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))))
(log.f64 (pow.f64 (E.f64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(log.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (.f64 (-.f64 y t) (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(.f64 (.f64 (-.f64 y t) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(.f64 (.f64 (-.f64 y z) (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(.f64 (.f64 (-.f64 y z) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(.f64 (neg.f64 (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(.f64 (sqrt.f64 (-.f64 y t)) (.f64 (sqrt.f64 (-.f64 y t)) (-.f64 y z)))
(.f64 (sqrt.f64 (-.f64 y z)) (.f64 (sqrt.f64 (-.f64 y z)) (-.f64 y t)))
(.f64 (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (.f64 (cbrt.f64 (-.f64 y t)) (-.f64 y z)))
(.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)) (.f64 (cbrt.f64 (-.f64 y z)) (-.f64 y t)))
(.f64 (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))))
(.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) (pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64)))
(.f64 (.f64 (-.f64 y t) (-.f64 y z)) #s(literal 1 binary64))
(*.f64 (-.f64 y t) (-.f64 y z))
(*.f64 (-.f64 y z) (-.f64 y t))
(.f64 #s(literal 1 binary64) (.f64 (-.f64 y t) (-.f64 y z)))
(pow.f64 (pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))) (sqrt.f64 #s(literal 3 binary64))) (sqrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) (.f64 (cbrt.f64 #s(literal 3 binary64)) (cbrt.f64 #s(literal 3 binary64)))) (cbrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (*.f64 (-.f64 y t) (-.f64 y z)) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (-.f64 y t) (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (*.f64 (-.f64 y t) (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (.f64 (.f64 (+.f64 t y) (-.f64 y t)) (-.f64 y z)) (+.f64 t y))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 y z)) (fma.f64 t (+.f64 t y) (.f64 y y)))
(/.f64 (.f64 (.f64 (+.f64 z y) (-.f64 y z)) (-.f64 y t)) (+.f64 z y))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 y t)) (fma.f64 z (+.f64 z y) (.f64 y y)))
(/.f64 (.f64 (-.f64 y t) (.f64 (+.f64 z y) (-.f64 y z))) (+.f64 z y))
(/.f64 (.f64 (-.f64 y t) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 z (+.f64 z y) (.f64 y y)))
(/.f64 (.f64 (-.f64 y z) (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(/.f64 (.f64 (-.f64 y z) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(/.f64 (.f64 (.f64 (+.f64 t y) (-.f64 y t)) (.f64 (+.f64 z y) (-.f64 y z))) (.f64 (+.f64 t y) (+.f64 z y)))
(/.f64 (.f64 (.f64 (+.f64 t y) (-.f64 y t)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (.f64 (+.f64 t y) (fma.f64 z (+.f64 z y) (.f64 y y))))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (.f64 (+.f64 z y) (-.f64 y z))) (.f64 (fma.f64 t (+.f64 t y) (.f64 y y)) (+.f64 z y)))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (.f64 (fma.f64 t (+.f64 t y) (.f64 y y)) (fma.f64 z (+.f64 z y) (.f64 y y))))
(/.f64 (.f64 (.f64 (+.f64 z y) (-.f64 y z)) (.f64 (+.f64 t y) (-.f64 y t))) (.f64 (+.f64 z y) (+.f64 t y)))
(/.f64 (.f64 (.f64 (+.f64 z y) (-.f64 y z)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (.f64 (+.f64 z y) (fma.f64 t (+.f64 t y) (.f64 y y))))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (.f64 (+.f64 t y) (-.f64 y t))) (.f64 (fma.f64 z (+.f64 z y) (.f64 y y)) (+.f64 t y)))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (.f64 (fma.f64 z (+.f64 z y) (.f64 y y)) (fma.f64 t (+.f64 t y) (.f64 y y))))
(cbrt.f64 (*.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) (pow.f64 (-.f64 y z) #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 (-.f64 y t) (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 (-.f64 y t) (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) #s(literal 2 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 3 binary64) (log.f64 (*.f64 (-.f64 y t) (-.f64 y z)))) #s(literal 1/3 binary64)))
(exp.f64 (.f64 (log.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) #s(literal 3 binary64)))
(exp.f64 (log.f64 (*.f64 (-.f64 y t) (-.f64 y z))))
(+.f64 (log.f64 (sqrt.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z)))) (log.f64 (sqrt.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z)))))
(+.f64 (log.f64 (*.f64 (cbrt.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z))) (cbrt.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z))))) (log.f64 (cbrt.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z)))))
(+.f64 (cosh.f64 (log.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (sinh.f64 (log.f64 (.f64 (-.f64 y t) (-.f64 y z)))))
(log.f64 (pow.f64 (exp.f64 (sqrt.f64 (-.f64 y z))) (*.f64 (-.f64 y t) (sqrt.f64 (-.f64 y z)))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (-.f64 y z))) (*.f64 (-.f64 y t) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)))))
(log.f64 (pow.f64 (exp.f64 (sqrt.f64 (-.f64 y t))) (*.f64 (-.f64 y z) (sqrt.f64 (-.f64 y t)))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (-.f64 y t))) (*.f64 (-.f64 y z) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)))))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))))
(log.f64 (pow.f64 (exp.f64 (-.f64 y t)) (-.f64 y z)))
(*.f64 (+.f64 (sqrt.f64 y) (sqrt.f64 z)) (-.f64 (sqrt.f64 y) (sqrt.f64 z)))
(*.f64 (neg.f64 (sqrt.f64 (-.f64 y z))) (neg.f64 (sqrt.f64 (-.f64 y z))))
(*.f64 (sqrt.f64 (-.f64 y z)) (sqrt.f64 (-.f64 y z)))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y z)))
(*.f64 (cbrt.f64 (-.f64 y z)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)))
(*.f64 (-.f64 y z) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 y z))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) (sqrt.f64 #s(literal 3 binary64))) (sqrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) (*.f64 (cbrt.f64 #s(literal 3 binary64)) (cbrt.f64 #s(literal 3 binary64)))) (cbrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (-.f64 y z) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (-.f64 y z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 3 binary64))
(pow.f64 (-.f64 y z) #s(literal 1 binary64))
(/.f64 (neg.f64 (*.f64 (+.f64 z y) (-.f64 y z))) (neg.f64 (+.f64 z y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (fma.f64 z (+.f64 z y) (*.f64 y y))))
(/.f64 (*.f64 (+.f64 z y) (-.f64 y z)) (+.f64 z y))
(/.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 z (+.f64 z y) (*.f64 y y)))
(cbrt.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 y z) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 y y) (+.f64 z y)) (/.f64 (.f64 z z) (+.f64 z y)))
(-.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 z (+.f64 z y) (.f64 y y))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 z (+.f64 z y) (.f64 y y))))
(-.f64 y z)
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (-.f64 y z))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64))) #s(literal 1/3 binary64)))
(exp.f64 (*.f64 (log.f64 (cbrt.f64 (-.f64 y z))) #s(literal 3 binary64)))
(exp.f64 (log.f64 (-.f64 y z)))
(+.f64 (log.f64 (sqrt.f64 (exp.f64 (-.f64 y z)))) (log.f64 (sqrt.f64 (exp.f64 (-.f64 y z)))))
(+.f64 (log.f64 (*.f64 (cbrt.f64 (exp.f64 (-.f64 y z))) (cbrt.f64 (exp.f64 (-.f64 y z))))) (log.f64 (cbrt.f64 (exp.f64 (-.f64 y z)))))
(+.f64 (cosh.f64 (log.f64 (-.f64 y z))) (sinh.f64 (log.f64 (-.f64 y z))))
(+.f64 y (*.f64 (neg.f64 (sqrt.f64 z)) (sqrt.f64 z)))
(+.f64 y (*.f64 (neg.f64 (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z)))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (-.f64 y z))) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))))
(log.f64 (exp.f64 (-.f64 y z)))
(*.f64 (+.f64 (sqrt.f64 y) (sqrt.f64 t)) (-.f64 (sqrt.f64 y) (sqrt.f64 t)))
(*.f64 (neg.f64 (sqrt.f64 (-.f64 y t))) (neg.f64 (sqrt.f64 (-.f64 y t))))
(*.f64 (sqrt.f64 (-.f64 y t)) (sqrt.f64 (-.f64 y t)))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y t)))
(*.f64 (cbrt.f64 (-.f64 y t)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)))
(*.f64 (-.f64 y t) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 y t))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) (sqrt.f64 #s(literal 3 binary64))) (sqrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) (*.f64 (cbrt.f64 #s(literal 3 binary64)) (cbrt.f64 #s(literal 3 binary64)))) (cbrt.f64 #s(literal 3 binary64)))
(pow.f64 (pow.f64 (-.f64 y t) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (-.f64 y t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 3 binary64))
(pow.f64 (-.f64 y t) #s(literal 1 binary64))
(/.f64 (neg.f64 (*.f64 (+.f64 t y) (-.f64 y t))) (neg.f64 (+.f64 t y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (neg.f64 (fma.f64 t (+.f64 t y) (*.f64 y y))))
(/.f64 (*.f64 (+.f64 t y) (-.f64 y t)) (+.f64 t y))
(/.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 t (+.f64 t y) (*.f64 y y)))
(cbrt.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 y y) (+.f64 t y)) (/.f64 (.f64 t t) (+.f64 t y)))
(-.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 t (+.f64 t y) (.f64 y y))) (/.f64 (pow.f64 t #s(literal 3 binary64)) (fma.f64 t (+.f64 t y) (.f64 y y))))
(-.f64 y t)
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (-.f64 y t))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64))) #s(literal 1/3 binary64)))
(exp.f64 (*.f64 (log.f64 (cbrt.f64 (-.f64 y t))) #s(literal 3 binary64)))
(exp.f64 (log.f64 (-.f64 y t)))
(+.f64 (log.f64 (sqrt.f64 (exp.f64 (-.f64 y t)))) (log.f64 (sqrt.f64 (exp.f64 (-.f64 y t)))))
(+.f64 (log.f64 (*.f64 (cbrt.f64 (exp.f64 (-.f64 y t))) (cbrt.f64 (exp.f64 (-.f64 y t))))) (log.f64 (cbrt.f64 (exp.f64 (-.f64 y t)))))
(+.f64 (cosh.f64 (log.f64 (-.f64 y t))) (sinh.f64 (log.f64 (-.f64 y t))))
(+.f64 y (*.f64 (neg.f64 (sqrt.f64 t)) (sqrt.f64 t)))
(+.f64 y (*.f64 (neg.f64 (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (cbrt.f64 t)))
(log.f64 (pow.f64 (exp.f64 (cbrt.f64 (-.f64 y t))) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))))
(log.f64 (exp.f64 (-.f64 y t)))

eval111.0ms (1.7%)

Memory: -14.6MiB live, 94.2MiB allocated; 46ms collecting garbage
Compiler: Compiled 7 290 to 1 447 computations (80.2% saved)

prune11.0ms (0.2%)

Memory

29.2MiB live, 29.2MiB allocated; 0ms collecting garbage

Pruning

13 alts after pruning (13 fresh and 0 done)

	Pruned	Kept	Total
New	302	13	315
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	303	13	316

Accuracy

100.0%

Counts

316 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.8%	(-.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal -1 binary64)) #s(literal -1 binary64)))
▶	99.2%	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
▶	98.8%	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
	68.1%	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
	92.4%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (fma.f64 (-.f64 (neg.f64 z) t) y (*.f64 t z)))))
	97.9%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
	53.6%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
	61.8%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
	78.5%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
▶	82.0%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
	82.5%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
▶	79.0%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
▶	74.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Compiler

Compiled 442 to 346 computations (21.7% saved)

simplify181.0ms (2.7%)

Memory

-0.1MiB live, 190.3MiB allocated; 29ms collecting garbage

Localize:

Found 17 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(-.f64 y t)
cost-diff	0	(/.f64 x (-.f64 y t))
cost-diff	0	(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
cost-diff	0	(/.f64 (neg.f64 x) t)
cost-diff	0	(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
cost-diff	0	#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
cost-diff	0	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
cost-diff	0	(*.f64 (-.f64 y t) z)
cost-diff	0	(/.f64 x (*.f64 (-.f64 y t) z))
cost-diff	0	(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
cost-diff	0	(-.f64 y z)
cost-diff	0	(/.f64 x (-.f64 y z))
cost-diff	0	(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	28	196
0	42	196
1	54	196
2	66	196
3	90	196
4	143	196
5	450	196
6	3521	196
7	7459	196
0	8099	196

Stop Event

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

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
#s(literal 1 binary64)
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 x (-.f64 y z))
x
(-.f64 y z)
y
z
(-.f64 y t)
t
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y t) z))
x
(*.f64 (-.f64 y t) z)
(-.f64 y t)
y
t
z
#s(literal 1 binary64)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
(/.f64 (neg.f64 x) t)
(neg.f64 x)
x
t
(-.f64 y z)
y
z
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(literal 1 binary64)
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 x (-.f64 y t))
x
(-.f64 y t)
y
t
(-.f64 y z)
z

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(literal 1 binary64)
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 x (-.f64 y z))
x
(-.f64 y z)
y
z
(-.f64 y t)
t
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))
(/.f64 x (*.f64 (-.f64 y t) z))
x
(*.f64 (-.f64 y t) z)
(-.f64 y t)
y
t
z
#s(literal 1 binary64)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
(/.f64 (neg.f64 x) t)
(neg.f64 x)
x
t
(-.f64 y z)
y
z
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(literal 1 binary64)
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 x (-.f64 y t))
x
(-.f64 y t)
y
t
(-.f64 y z)
z

localize80.0ms (1.2%)

Memory

2.9MiB live, 233.3MiB allocated; 32ms collecting garbage

Localize:

Found 17 expressions of interest:

New	Metric	Score
accuracy	0.0	(-.f64 y t)
accuracy	0.0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
accuracy	0.01171875	(/.f64 x (-.f64 y t))
accuracy	1.8050876516152388	(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
accuracy	0.0	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
accuracy	0.0	(neg.f64 x)
accuracy	3.482823520501477	(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
accuracy	22.764505278378802	#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
accuracy	0.0	(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
accuracy	0.0234375	(*.f64 (-.f64 y t) z)
accuracy	4.504042484664614	(/.f64 x (*.f64 (-.f64 y t) z))
accuracy	13.417333449338617	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
accuracy	16.233969763908853	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
accuracy	0.0	(-.f64 y t)
accuracy	0.0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
accuracy	0.015625	(/.f64 x (-.f64 y z))
accuracy	1.0971916031032294	(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))

Samples

55.0ms

256×

valid

Compiler

Compiled 168 to 24 computations (85.7% saved)

Precisions

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

ival-div: 15.0ms (55.7% of total)

ival-sub: 6.0ms (22.3% of total)

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

ival-add: 1.0ms (3.7% of total)

ival-neg: 1.0ms (3.7% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series82.0ms (1.2%)

Memory

-22.5MiB live, 169.1MiB allocated; 19ms collecting garbage

Counts

18 → 327

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 x (-.f64 y z))
(-.f64 y z)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y t) z))
(*.f64 (-.f64 y t) z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
(/.f64 (neg.f64 x) t)
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 x (-.f64 y t))
(-.f64 y t)
(neg.f64 x)

Outputs
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Calls

12 calls:

Time	Variable		Point	Expression
30.0ms	t	@	-inf	((- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (- 1 (/ x (* (- y z) (- y t)))) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (- 1 (/ (/ x (- y t)) (- y z))) (/ (/ x (- y t)) (- y z)) (/ x (- y t)) (- y t) (neg x))
11.0ms	x	@	-inf	((- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (- 1 (/ x (* (- y z) (- y t)))) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (- 1 (/ (/ x (- y t)) (- y z))) (/ (/ x (- y t)) (- y z)) (/ x (- y t)) (- y t) (neg x))
6.0ms	x	@	0	((- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (- 1 (/ x (* (- y z) (- y t)))) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (- 1 (/ (/ x (- y t)) (- y z))) (/ (/ x (- y t)) (- y z)) (/ x (- y t)) (- y t) (neg x))
5.0ms	y	@	inf	((- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (- 1 (/ x (* (- y z) (- y t)))) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (- 1 (/ (/ x (- y t)) (- y z))) (/ (/ x (- y t)) (- y z)) (/ x (- y t)) (- y t) (neg x))
4.0ms	x	@	inf	((- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (- 1 (/ x (* (- y z) (- y t)))) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (- 1 (/ (/ x (- y t)) (- y z))) (/ (/ x (- y t)) (- y z)) (/ x (- y t)) (- y t) (neg x))

simplify193.0ms (2.9%)

Memory

6.9MiB live, 343.8MiB allocated; 72ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1235	11058
1	3554	10522
0	8491	10279

Stop Event

1×	iter limit
1×	node limit

Counts

327 → 327

Calls

Call 1

Inputs
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Outputs
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (/ x (- y z)) (/.f64 x (-.f64 y z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (/.f64 x z) (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 x z) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ (neg x) t) (/.f64 (neg.f64 x) t))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (/ x (- y t)) (/.f64 x (-.f64 y t)))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (neg x) (neg.f64 x))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (-.f64 y t) z)) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 x)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 x)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (*.f64 (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 x)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (.f64 t t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (.f64 (.f64 z z) (*.f64 t t)))) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 t z)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (*.f64 z z)) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) (.f64 (.f64 z z) (*.f64 t t))))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 t z)) (*.f64 z z)))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 x) z))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) (neg.f64 (fma.f64 x (/.f64 y (*.f64 z z)) (/.f64 x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 z #s(literal 3 binary64)))) (/.f64 x (.f64 z z))) y (/.f64 (neg.f64 x) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 z #s(literal 4 binary64)))) (/.f64 x (pow.f64 z #s(literal 3 binary64)))) y) (/.f64 x (*.f64 z z))) y (/.f64 (neg.f64 x) z)))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) (neg.f64 z))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y z) (-.f64 y z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (.f64 t t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (.f64 (.f64 z z) (*.f64 t t)))) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 t z)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (/.f64 x t) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 3 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (.f64 t z))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 4 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (.f64 t z))) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 x) (*.f64 t z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 3 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (.f64 t z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 4 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (.f64 t z))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 z) t))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (*.f64 z z)) (/.f64 (/.f64 x t) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) (.f64 (.f64 z z) (*.f64 t t))))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 t z)) (*.f64 z z)))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 x t) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (/.f64 y (*.f64 z z)) (/.f64 x t) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (/.f64 y (pow.f64 z #s(literal 3 binary64))) (/.f64 x t) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 x (pow.f64 z #s(literal 4 binary64))) (/.f64 y t) (/.f64 x (.f64 (pow.f64 z #s(literal 3 binary64)) t))) y (/.f64 x (.f64 (*.f64 z z) t))) y (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (.f64 t t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (.f64 (.f64 z z) (*.f64 t t)))) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 t z)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) y) (*.f64 z z)) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) (.f64 (.f64 z z) (*.f64 t t))))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 t z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 t z)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 (.f64 t z) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (pow.f64 (.f64 t z) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 t z)) (*.f64 z z)))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 x) t))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) (neg.f64 (fma.f64 x (/.f64 y (*.f64 t t)) (/.f64 x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 t #s(literal 3 binary64)))) (/.f64 x (.f64 t t))) y (/.f64 (neg.f64 x) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 t #s(literal 4 binary64)))) (/.f64 x (pow.f64 t #s(literal 3 binary64)))) y) (/.f64 x (*.f64 t t))) y (/.f64 (neg.f64 x) t)))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) (neg.f64 t))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- y t) (-.f64 y t))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 t z)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) y) x) (*.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) x) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y)) (.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 (+.f64 t z)) (.f64 (.f64 t x) (.f64 (neg.f64 (+.f64 t z)) z)))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y))) (.f64 y y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) (/.f64 x y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) (/.f64 (fma.f64 x (/.f64 z y) x) y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 (.f64 z z) y) (/.f64 x y) x) (.f64 (neg.f64 x) (/.f64 z y))) y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (fma.f64 x (pow.f64 (/.f64 z y) #s(literal 3 binary64)) x) (neg.f64 (fma.f64 (/.f64 (.f64 z z) y) (/.f64 x y) (/.f64 (.f64 z x) y)))) y))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) y)
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 z y) #s(literal -1 binary64) #s(literal 1 binary64)) y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 t z)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (/.f64 x y) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (+.f64 (/.f64 (+.f64 (/.f64 (.f64 (.f64 t t) x) (pow.f64 y #s(literal 3 binary64))) (/.f64 x y)) z) #s(literal 1 binary64)) (.f64 (/.f64 t (.f64 y y)) (/.f64 (neg.f64 x) z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 x y) z))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t t) (/.f64 x (.f64 y y)) x) z) (*.f64 (/.f64 (neg.f64 t) y) (/.f64 x z))) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 t y) #s(literal 3 binary64)) (/.f64 x z) (/.f64 x z)) (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) (.f64 (/.f64 (.f64 t t) y) (/.f64 x y))) z))) y))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) (*.f64 z y))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 t) (/.f64 z y) z) y))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) y) x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) x) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y)) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 (+.f64 t z)) (.f64 (.f64 t x) (.f64 (neg.f64 (+.f64 t z)) z)))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y))) (.f64 y y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 x t) #s(literal -1 binary64) (neg.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x (.f64 y y)) (*.f64 (/.f64 z t) (/.f64 x y))))) y))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 #s(literal -1 binary64) (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 (fma.f64 (pow.f64 (/.f64 z y) #s(literal 3 binary64)) (/.f64 x t) (.f64 (/.f64 (.f64 z z) t) (/.f64 x (*.f64 y y)))))) y))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 t z)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 y y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 t z)) y) x) (*.f64 y y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) x) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y)) (.f64 y y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 (+.f64 t z)) (.f64 (.f64 t x) (.f64 (neg.f64 (+.f64 t z)) z)))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 t z)) x) y))) (.f64 y y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) (/.f64 x y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) (/.f64 (fma.f64 t (/.f64 x y) x) y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (fma.f64 (.f64 t t) (/.f64 x (.f64 y y)) x) (*.f64 (neg.f64 t) (/.f64 x y))) y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (fma.f64 (pow.f64 t #s(literal 3 binary64)) (/.f64 x (pow.f64 y #s(literal 3 binary64))) x) (neg.f64 (fma.f64 (/.f64 (.f64 t t) y) (/.f64 x y) (.f64 t (/.f64 x y))))) y))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) y)
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- y t) (*.f64 (fma.f64 (/.f64 t y) #s(literal -1 binary64) #s(literal 1 binary64)) y))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 t z) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 t z) x (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 x (/.f64 (+.f64 t z) y) x) (*.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 t z) z) x) t (.f64 (+.f64 t z) (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))))) y) (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) x)) (.f64 (.f64 z x) t)) (neg.f64 y)) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 (fma.f64 x (/.f64 z y) x)) (neg.f64 y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 z x (/.f64 (.f64 (.f64 z z) x) y)) y) x)) (neg.f64 y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 z x (/.f64 (neg.f64 (fma.f64 x (/.f64 (pow.f64 z #s(literal 3 binary64)) y) (.f64 (.f64 z z) x))) (neg.f64 y))) y) x)) (neg.f64 y)))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y z) (*.f64 (neg.f64 y) (-.f64 (/.f64 z y) #s(literal 1 binary64))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 t z) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 t z) x (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z)) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z)) (neg.f64 y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t (/.f64 x z) (/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y)) z)) (neg.f64 y))) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 y) (fma.f64 t (/.f64 z y) (neg.f64 z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 x (/.f64 (+.f64 t z) y) x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 t z) z) x) t (.f64 (+.f64 t z) (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))))) y) (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) x)) (.f64 (.f64 z x) t)) (neg.f64 y)) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) y) (/.f64 (.f64 z z) t)) (/.f64 (*.f64 z x) t)) (neg.f64 y)) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 z #s(literal 3 binary64)) t) (/.f64 x y) (.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 z z) x) t))) (neg.f64 y)) (/.f64 (.f64 z x) t)) (neg.f64 y)) (/.f64 x t)) (neg.f64 y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 t z) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 t z) x (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 x (/.f64 (+.f64 t z) y) x) (*.f64 y y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))) y) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 t z) z) x) t (.f64 (+.f64 t z) (fma.f64 (.f64 t x) z (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) (neg.f64 x))))) y) (.f64 (pow.f64 (+.f64 t z) #s(literal 2 binary64)) x)) (.f64 (.f64 z x) t)) (neg.f64 y)) (.f64 (+.f64 t z) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 (fma.f64 t (/.f64 x y) x)) (neg.f64 y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) y) x)) (neg.f64 y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t x (/.f64 (neg.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y))) (neg.f64 y))) y) x)) (neg.f64 y)))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- y t) (*.f64 (neg.f64 y) (-.f64 (/.f64 t y) #s(literal 1 binary64))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (-.f64 y t)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 z y) (/.f64 x y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 z (pow.f64 y #s(literal 3 binary64))) (/.f64 x (-.f64 y t))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 z (-.f64 y t))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) (fma.f64 (/.f64 z y) (/.f64 x y) (/.f64 x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) (fma.f64 (fma.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 y y)))) z (/.f64 x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) (fma.f64 (fma.f64 (fma.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (pow.f64 y #s(literal 3 binary64))))) z (.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y)))) z (/.f64 x y)))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- y z) (fma.f64 #s(literal -1 binary64) z y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (-.f64 y t)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (+.f64 (/.f64 x (-.f64 y t)) z) z))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (* (- y t) z) (*.f64 (-.f64 y t) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 z y) (/.f64 x y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 z (pow.f64 y #s(literal 3 binary64))) (/.f64 x (-.f64 y t))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 z (-.f64 y t))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) (neg.f64 (fma.f64 x (/.f64 z (.f64 (.f64 y y) t)) (/.f64 (/.f64 x t) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (neg.f64 (fma.f64 x (/.f64 z (.f64 (pow.f64 y #s(literal 3 binary64)) t)) (/.f64 x (.f64 (.f64 y y) t)))) z (/.f64 (neg.f64 x) (.f64 t y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (neg.f64 (fma.f64 x (/.f64 z (.f64 (pow.f64 y #s(literal 4 binary64)) t)) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) t)))) z (/.f64 (neg.f64 x) (.f64 (.f64 y y) t))) z (/.f64 (neg.f64 x) (*.f64 t y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (-.f64 y t)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 z y) (/.f64 x y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 z (pow.f64 y #s(literal 3 binary64))) (/.f64 x (-.f64 y t))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 z (-.f64 y t))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (/.f64 x z) (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (-.f64 y t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (/.f64 (*.f64 y x) z)) (-.f64 y t))) z))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) (/.f64 (fma.f64 x (/.f64 y z) x) (neg.f64 z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) x)) (/.f64 (.f64 y x) z)) z))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (neg.f64 (fma.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)) x)) (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (/.f64 (.f64 y x) z))) z))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- y z) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (/.f64 x z) (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (-.f64 y t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (/.f64 (*.f64 y x) z)) (-.f64 y t))) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t)) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (*.f64 (/.f64 y t) (/.f64 x z))) (/.f64 x t)) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (*.f64 (pow.f64 (/.f64 y z) #s(literal 3 binary64)) (/.f64 x t)))) (/.f64 x t)) z))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (/.f64 x z) (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (-.f64 y t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (/.f64 (*.f64 y x) z)) (-.f64 y t))) z))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (*.f64 (/.f64 (neg.f64 x) z) (/.f64 y (-.f64 y t))) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) (neg.f64 z)) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 y y) z) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (.f64 (neg.f64 x) (/.f64 (.f64 y y) (-.f64 y t)))) (neg.f64 z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) (/.f64 (fma.f64 x (/.f64 y z) x) (neg.f64 z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (neg.f64 x) (/.f64 (.f64 y y) z) (.f64 (neg.f64 y) x)) z) #s(literal -1 binary64) x) (neg.f64 z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (.f64 (.f64 y y) x)) (neg.f64 z)) (*.f64 y x)) (neg.f64 z)) x) (neg.f64 z)))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) (neg.f64 z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (*.f64 (/.f64 (neg.f64 x) z) (/.f64 y (-.f64 y t))) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) (neg.f64 z)) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 y y) z) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (.f64 (neg.f64 x) (/.f64 (.f64 y y) (-.f64 y t)))) (neg.f64 z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t))) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x z) (/.f64 (.f64 y x) t)) z) (/.f64 x t))) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 x (/.f64 y t) (/.f64 (neg.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) t))) (neg.f64 z))) z) (/.f64 x t))) (neg.f64 z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (*.f64 (/.f64 (neg.f64 x) z) (/.f64 y (-.f64 y t))) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) (neg.f64 z)) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 y y) z) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (.f64 (neg.f64 x) (/.f64 (.f64 y y) (-.f64 y t)))) (neg.f64 z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (/.f64 (neg.f64 x) (pow.f64 y #s(literal 3 binary64))) (-.f64 y z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (/.f64 t z) (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 (/.f64 x y) z)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 t z) (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (*.f64 y y)) z))) t (/.f64 (/.f64 x y) z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) z))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (/.f64 t z) (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 (/.f64 x y) z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 t z) (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (*.f64 y y)) z))) t (/.f64 (/.f64 x y) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (/.f64 (neg.f64 x) (pow.f64 y #s(literal 3 binary64))) (-.f64 y z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (/.f64 (neg.f64 x) (pow.f64 y #s(literal 3 binary64))) (-.f64 y z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) (fma.f64 (fma.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 y y)))) t (/.f64 x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) (fma.f64 (fma.f64 (fma.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (pow.f64 y #s(literal 3 binary64))))) t (.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y)))) t (/.f64 x y)))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- y t) (fma.f64 #s(literal -1 binary64) t y))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) (-.f64 y z))) t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) z) #s(literal 1 binary64)) (.f64 (/.f64 y (.f64 t t)) (/.f64 x z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) z)) (*.f64 (/.f64 y t) (/.f64 x z))) t))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) z)) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) z)) t))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 y (/.f64 z t) (neg.f64 z)) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) (-.f64 y z))) t))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) (-.f64 y z))) t))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) (/.f64 (fma.f64 x (/.f64 y t) x) (neg.f64 t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) x)) (/.f64 (.f64 y x) t)) t))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (neg.f64 (fma.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)) x)) (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (.f64 y x) t))) t))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- y t) (*.f64 (-.f64 (/.f64 y t) #s(literal 1 binary64)) t))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) (neg.f64 t)) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 y y) t) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (.f64 y y) (neg.f64 x)) (-.f64 y z))) (neg.f64 t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) (neg.f64 t)) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t) (.f64 x (/.f64 y (neg.f64 z)))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t) (.f64 x (/.f64 y (neg.f64 z)))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 y y) x) z))) (neg.f64 t)) (/.f64 (.f64 y x) z)) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 y) (/.f64 z t) z) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 y y) t) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (.f64 y y) (neg.f64 x)) (-.f64 y z))) (neg.f64 t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) (neg.f64 t)) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 y y) t) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ (/ x (- y t)) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (.f64 y y) (neg.f64 x)) (-.f64 y z))) (neg.f64 t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) (/.f64 (fma.f64 x (/.f64 y t) x) (neg.f64 t)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) (/.f64 (fma.f64 (/.f64 (fma.f64 (neg.f64 x) (/.f64 (.f64 y y) t) (.f64 (neg.f64 y) x)) t) #s(literal -1 binary64) x) (neg.f64 t)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (.f64 (.f64 y y) x)) (neg.f64 t)) (*.f64 y x)) (neg.f64 t)) x) (neg.f64 t)))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))
#s(approx (- y t) (*.f64 (fma.f64 (/.f64 y t) #s(literal -1 binary64) #s(literal 1 binary64)) (neg.f64 t)))

rewrite235.0ms (3.5%)

Memory

26.1MiB live, 211.3MiB allocated; 32ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	28	163
0	42	163
1	484	158
2	5848	158
0	8068	158

Stop Event

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

Counts

18 → 601

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 x (-.f64 y z))
(-.f64 y z)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y t) z))
(*.f64 (-.f64 y t) z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
(/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))
(/.f64 (neg.f64 x) t)
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 x (-.f64 y t))
(-.f64 y t)
(neg.f64 x)

Outputs
(*.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (-.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(*.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)))
(pow.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(exp.f64 (*.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 (cosh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (/.f64 (/.f64 x (-.f64 y t)) (.f64 (+.f64 z y) (-.f64 y z))) (+.f64 z y))
(.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 z (+.f64 z y) (.f64 y y)))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y z))) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) (sqrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y z)) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y z)) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (-.f64 y z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t)))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (-.f64 y z)))
(*.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(/.f64 (/.f64 x (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 (-.f64 y z)))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y t))) (-.f64 y z))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 (-.f64 y t)))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y z))) (-.f64 y t))
(/.f64 (.f64 #s(literal 1 binary64) x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z)))
(/.f64 (.f64 #s(literal 1 binary64) x) (.f64 (-.f64 y t) (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (neg.f64 (-.f64 y z))))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 (/.f64 x (-.f64 y z)) (neg.f64 (neg.f64 (-.f64 y t))))
(/.f64 (/.f64 x (-.f64 y z)) (neg.f64 (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 x (neg.f64 (*.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(/.f64 x (*.f64 (neg.f64 (-.f64 y t)) (-.f64 y z)))
(/.f64 x (*.f64 (-.f64 y t) (-.f64 y z)))
(neg.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(cbrt.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(+.f64 (cosh.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sinh.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (/.f64 x (.f64 (+.f64 z y) (-.f64 y z))) (+.f64 z y))
(.f64 (/.f64 x (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 z (+.f64 z y) (.f64 y y)))
(*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y z))) (/.f64 (cbrt.f64 x) (sqrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y z))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y z)))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y z)))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y z)))) (sqrt.f64 (/.f64 x (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y z)))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (sqrt.f64 (/.f64 x (-.f64 y z))))
(*.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (neg.f64 (-.f64 y z))))
(*.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (neg.f64 (cbrt.f64 (/.f64 x (-.f64 y z)))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (-.f64 y z))))
(*.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (neg.f64 (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(pow.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (/.f64 x (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(/.f64 x (neg.f64 (neg.f64 (-.f64 y z))))
(/.f64 x (neg.f64 (-.f64 y z)))
(/.f64 x (-.f64 y z))
(neg.f64 (/.f64 x (-.f64 y z)))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 (-.f64 y z) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x (-.f64 y z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (-.f64 y z))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 x (-.f64 y z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 x (-.f64 y z))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (-.f64 y z)))) (sinh.f64 (log.f64 (/.f64 x (-.f64 y z)))))
(log.f64 (/.f64 #s(literal 1 binary64) (exp.f64 (/.f64 x (-.f64 y z)))))
(log.f64 (exp.f64 (/.f64 x (-.f64 y z))))
(*.f64 (+.f64 (sqrt.f64 y) (sqrt.f64 z)) (-.f64 (sqrt.f64 y) (sqrt.f64 z)))
(*.f64 (neg.f64 (sqrt.f64 (-.f64 y z))) (neg.f64 (sqrt.f64 (-.f64 y z))))
(*.f64 (sqrt.f64 (-.f64 y z)) (sqrt.f64 (-.f64 y z)))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y z)))
(*.f64 (cbrt.f64 (-.f64 y z)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (-.f64 y z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 3 binary64))
(pow.f64 (-.f64 y z) #s(literal 1 binary64))
(/.f64 (neg.f64 (*.f64 (+.f64 z y) (-.f64 y z))) (neg.f64 (+.f64 z y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (neg.f64 (fma.f64 z (+.f64 z y) (*.f64 y y))))
(/.f64 (*.f64 (+.f64 z y) (-.f64 y z)) (+.f64 z y))
(/.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 z (+.f64 z y) (*.f64 y y)))
(cbrt.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 y z) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 y y) (+.f64 z y)) (/.f64 (.f64 z z) (+.f64 z y)))
(-.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 z (+.f64 z y) (.f64 y y))) (/.f64 (pow.f64 z #s(literal 3 binary64)) (fma.f64 z (+.f64 z y) (.f64 y y))))
(-.f64 y z)
(exp.f64 (*.f64 (log.f64 (-.f64 y z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 y z)))
(+.f64 (cosh.f64 (.f64 (log.f64 (-.f64 y z)) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (-.f64 y z)) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (-.f64 y z))) (sinh.f64 (log.f64 (-.f64 y z))))
(+.f64 y (*.f64 (neg.f64 (sqrt.f64 z)) (sqrt.f64 z)))
(+.f64 y (*.f64 (neg.f64 (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z)))
(log.f64 (exp.f64 (-.f64 y z)))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))))
(.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)))) (sinh.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)))))
(log.f64 (exp.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))))
(.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))))
(+.f64 (cosh.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))))
(.f64 (neg.f64 (sqrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))) (neg.f64 (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)))))
(.f64 (sqrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))))
(.f64 (cbrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) (pow.f64 (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 2 binary64)))
(.f64 #s(literal 1 binary64) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))
(pow.f64 (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(literal 3 binary64))
(pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)) #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) (/.f64 x (*.f64 (-.f64 y t) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64)) #s(literal -1 binary64))) (neg.f64 (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) z)))))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64)) #s(literal -1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) (/.f64 x (*.f64 (-.f64 y t) z)))))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64)) #s(literal -1 binary64)) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) z))))
(fma.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 z)) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 z)) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) (-.f64 y t)) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y t) z))) (/.f64 (cbrt.f64 x) (sqrt.f64 (.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) (-.f64 y t)) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) z) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) z) #s(literal 1 binary64))
(fma.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z)))) (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z)))) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (*.f64 (neg.f64 z) (-.f64 y t))) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) z) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))
(fma.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64)) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (*.f64 (neg.f64 z) (-.f64 y t))) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) z) #s(literal 1 binary64))
(fma.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(cbrt.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64)) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))))
(-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z)))) (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z)))))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z)))))
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) z)))
(exp.f64 (.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)))
(exp.f64 (log1p.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(+.f64 (cosh.f64 (.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))))
(+.f64 (/.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y t) z)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) z)))))
(+.f64 (cosh.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y t) z)))) (sinh.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y t) z)))))
(+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) z)))
(log.f64 (exp.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal -1 binary64))))
(.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 z)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 (-.f64 y t) z))))
(*.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y t) z))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 (-.f64 y t) z))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) z))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) z))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z)))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z)))))
(.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)))
(.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (neg.f64 z) (-.f64 y t))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (-.f64 y t) z)))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) z))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y t) z))) (pow.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 2 binary64)))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (neg.f64 z) (-.f64 y t))))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (-.f64 y t) z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) z))
(.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y t) z)))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (sqrt.f64 z)) (sqrt.f64 z))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z))
(/.f64 (/.f64 x (sqrt.f64 (.f64 (-.f64 y t) z))) (sqrt.f64 (.f64 (-.f64 y t) z)))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64))) (cbrt.f64 (.f64 (-.f64 y t) z)))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 (*.f64 (/.f64 x (-.f64 y t)) #s(literal 1 binary64)) z)
(/.f64 (.f64 x #s(literal 1 binary64)) (.f64 (neg.f64 z) (-.f64 y t)))
(/.f64 (.f64 x #s(literal 1 binary64)) (.f64 (-.f64 y t) z))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (neg.f64 (*.f64 (neg.f64 z) (-.f64 y t))))
(/.f64 x (*.f64 (neg.f64 z) (-.f64 y t)))
(/.f64 x (*.f64 (-.f64 y t) z))
(neg.f64 (/.f64 x (*.f64 (-.f64 y t) z)))
(cbrt.f64 (.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 2 binary64)))
(exp.f64 (+.f64 (log.f64 (/.f64 x (*.f64 (-.f64 y t) z))) #s(literal 0 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(+.f64 (cosh.f64 (+.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 0 binary64))) (sinh.f64 (+.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 0 binary64))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z)))) (sinh.f64 (log.f64 (/.f64 x (.f64 (-.f64 y t) z)))))
(log.f64 (pow.f64 (E.f64) (/.f64 x (*.f64 (-.f64 y t) z))))
(log.f64 (exp.f64 (/.f64 x (*.f64 (-.f64 y t) z))))
(.f64 (.f64 (-.f64 y t) (sqrt.f64 z)) (sqrt.f64 z))
(.f64 (.f64 (-.f64 y t) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z))
(.f64 (.f64 z (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(.f64 (.f64 z (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(.f64 (neg.f64 (sqrt.f64 (.f64 (-.f64 y t) z))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 y t) z))))
(.f64 (sqrt.f64 z) (.f64 (sqrt.f64 z) (-.f64 y t)))
(.f64 (sqrt.f64 (-.f64 y t)) (.f64 (sqrt.f64 (-.f64 y t)) z))
(.f64 (sqrt.f64 (.f64 (-.f64 y t) z)) (sqrt.f64 (*.f64 (-.f64 y t) z)))
(.f64 (pow.f64 (cbrt.f64 z) #s(literal 2 binary64)) (.f64 (cbrt.f64 z) (-.f64 y t)))
(.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (.f64 (cbrt.f64 (-.f64 y t)) z))
(.f64 (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) #s(literal 2 binary64)) (cbrt.f64 (*.f64 (-.f64 y t) z)))
(.f64 (cbrt.f64 (.f64 (-.f64 y t) z)) (pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) z)) #s(literal 2 binary64)))
(*.f64 (-.f64 y t) z)
(*.f64 z (-.f64 y t))
(pow.f64 (sqrt.f64 (*.f64 (-.f64 y t) z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (-.f64 y t) z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 (-.f64 y t) z)) #s(literal 3 binary64))
(pow.f64 (*.f64 (-.f64 y t) z) #s(literal 1 binary64))
(/.f64 (.f64 (.f64 (+.f64 t y) (-.f64 y t)) z) (+.f64 t y))
(/.f64 (.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) z) (fma.f64 t (+.f64 t y) (.f64 y y)))
(/.f64 (.f64 z (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(/.f64 (.f64 z (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(cbrt.f64 (*.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 (-.f64 y t) z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 (-.f64 y t) z) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (*.f64 (-.f64 y t) z)))
(+.f64 (cosh.f64 (.f64 (log.f64 (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (.f64 (-.f64 y t) z)) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (.f64 (-.f64 y t) z))) (sinh.f64 (log.f64 (.f64 (-.f64 y t) z))))
(log.f64 (pow.f64 (exp.f64 z) (-.f64 y t)))
(.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (-.f64 #s(literal 1 binary64) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))))
(.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64))) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64))) (fma.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))) (/.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64)) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)) #s(literal 1 binary64))) (/.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64)) (fma.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) (+.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)) #s(literal 1 binary64))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))
(exp.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(+.f64 (cosh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))))
(+.f64 #s(literal 1 binary64) (.f64 (neg.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(+.f64 #s(literal 1 binary64) (.f64 (neg.f64 (pow.f64 (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64))) (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(log.f64 (/.f64 (E.f64) (exp.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64))) (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (.f64 #s(literal 1 binary64) (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (neg.f64 (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(.f64 (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) (pow.f64 (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64)))
(.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))
(pow.f64 (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 3 binary64))
(pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))
(cbrt.f64 (.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(exp.f64 (.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(+.f64 (cosh.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))) (sinh.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))))
(+.f64 (cosh.f64 (.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))) (sinh.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z))))))
(log.f64 (exp.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) (-.f64 y z)))))
(.f64 (/.f64 (/.f64 x t) (.f64 (+.f64 z y) (-.f64 y z))) (+.f64 z y))
(.f64 (/.f64 (/.f64 x t) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 z (+.f64 z y) (.f64 y y)))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x t)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x t)) (cbrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y z))) (/.f64 (cbrt.f64 (/.f64 x t)) (sqrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 x) t) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) t) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x t) (-.f64 y z)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x t) (-.f64 y z)))))
(*.f64 (sqrt.f64 (/.f64 x t)) (/.f64 (sqrt.f64 (/.f64 x t)) (-.f64 y z)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 t (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) (sqrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x t)) (-.f64 y z)))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 t (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))))
(*.f64 (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (/.f64 (/.f64 x t) (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(/.f64 (/.f64 (/.f64 x t) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(/.f64 (/.f64 x t) (neg.f64 (neg.f64 (-.f64 y z))))
(/.f64 (/.f64 x t) (neg.f64 (-.f64 y z)))
(/.f64 (/.f64 x t) (-.f64 y z))
(/.f64 x (*.f64 (neg.f64 t) (-.f64 y z)))
(/.f64 x (neg.f64 (*.f64 t (-.f64 y z))))
(/.f64 x (*.f64 t (-.f64 y z)))
(neg.f64 (/.f64 (/.f64 x t) (-.f64 y z)))
(cbrt.f64 (/.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)) (pow.f64 (-.f64 y z) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x t) (-.f64 y z)))))
(log.f64 (exp.f64 (/.f64 (/.f64 x t) (-.f64 y z))))
(*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x t)))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 t)) (/.f64 (cbrt.f64 x) (sqrt.f64 t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x t))) (neg.f64 (sqrt.f64 (/.f64 x t))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x t))) (sqrt.f64 (/.f64 x t)))
(*.f64 (sqrt.f64 (/.f64 x t)) (neg.f64 (sqrt.f64 (/.f64 x t))))
(*.f64 (sqrt.f64 (/.f64 x t)) (sqrt.f64 (/.f64 x t)))
(*.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) t))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (neg.f64 (cbrt.f64 (/.f64 x t))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x t)))
(*.f64 (cbrt.f64 (/.f64 x t)) (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) t))
(pow.f64 (sqrt.f64 (/.f64 x t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 3 binary64))
(pow.f64 (/.f64 x t) #s(literal 1 binary64))
(/.f64 (/.f64 x (sqrt.f64 t)) (sqrt.f64 t))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (cbrt.f64 t))
(/.f64 x (neg.f64 (neg.f64 t)))
(/.f64 x (neg.f64 t))
(/.f64 x t)
(neg.f64 (/.f64 x t))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x t) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x t)))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 x t)) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 x t)) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x t))) (sinh.f64 (log.f64 (/.f64 x t))))
(log.f64 (exp.f64 (/.f64 x t)))
(*.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (-.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))) (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))))
(*.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 2 binary64)))
(pow.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))) (/.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) (fma.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(exp.f64 (*.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 (cosh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (/.f64 (/.f64 x (-.f64 y t)) (.f64 (+.f64 z y) (-.f64 y z))) (+.f64 z y))
(.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 z (+.f64 z y) (.f64 y y)))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(.f64 (/.f64 (/.f64 x (-.f64 y z)) (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y z))) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) (sqrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y z)) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 (-.f64 y t) (-.f64 y z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y z)) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (-.f64 y z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t)))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (.f64 (-.f64 y t) (-.f64 y z))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(*.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (-.f64 y z)))
(*.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 1 binary64))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(/.f64 (/.f64 (/.f64 x (-.f64 y t)) (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(/.f64 (/.f64 (/.f64 x (-.f64 y z)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(/.f64 (/.f64 x (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z)))) (sqrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))) #s(literal 2 binary64))) (cbrt.f64 (.f64 (-.f64 y t) (-.f64 y z))))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 (-.f64 y z)))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y t))) (-.f64 y z))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 (-.f64 y t)))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x (-.f64 y z))) (-.f64 y t))
(/.f64 (.f64 #s(literal 1 binary64) x) (.f64 (neg.f64 (-.f64 y t)) (-.f64 y z)))
(/.f64 (.f64 #s(literal 1 binary64) x) (.f64 (-.f64 y t) (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (neg.f64 (-.f64 y z))))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (-.f64 y z)))
(/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))
(/.f64 (/.f64 x (-.f64 y z)) (neg.f64 (neg.f64 (-.f64 y t))))
(/.f64 (/.f64 x (-.f64 y z)) (neg.f64 (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t))
(/.f64 x (neg.f64 (*.f64 (neg.f64 (-.f64 y t)) (-.f64 y z))))
(/.f64 x (*.f64 (neg.f64 (-.f64 y t)) (-.f64 y z)))
(/.f64 x (*.f64 (-.f64 y t) (-.f64 y z)))
(neg.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(cbrt.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(+.f64 (cosh.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))) (sinh.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))))
(log.f64 (exp.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z))))
(.f64 (/.f64 x (.f64 (+.f64 t y) (-.f64 y t))) (+.f64 t y))
(.f64 (/.f64 x (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 t (+.f64 t y) (.f64 y y)))
(*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 x) (sqrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))) (sqrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (neg.f64 (-.f64 y t))))
(*.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (neg.f64 (-.f64 y t))))
(*.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (neg.f64 (cbrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (-.f64 y t)) #s(literal 1 binary64))
(/.f64 (/.f64 x (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(/.f64 (/.f64 x (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(/.f64 x (neg.f64 (neg.f64 (-.f64 y t))))
(/.f64 x (neg.f64 (-.f64 y t)))
(/.f64 x (-.f64 y t))
(neg.f64 (/.f64 x (-.f64 y t)))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x (-.f64 y t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (-.f64 y t))))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 x (-.f64 y t))) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 x (-.f64 y t))) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (-.f64 y t)))) (sinh.f64 (log.f64 (/.f64 x (-.f64 y t)))))
(log.f64 (/.f64 #s(literal 1 binary64) (exp.f64 (/.f64 x (-.f64 y t)))))
(log.f64 (exp.f64 (/.f64 x (-.f64 y t))))
(*.f64 (+.f64 (sqrt.f64 y) (sqrt.f64 t)) (-.f64 (sqrt.f64 y) (sqrt.f64 t)))
(*.f64 (neg.f64 (sqrt.f64 (-.f64 y t))) (neg.f64 (sqrt.f64 (-.f64 y t))))
(*.f64 (sqrt.f64 (-.f64 y t)) (sqrt.f64 (-.f64 y t)))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y t)))
(*.f64 (cbrt.f64 (-.f64 y t)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (-.f64 y t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 3 binary64))
(pow.f64 (-.f64 y t) #s(literal 1 binary64))
(/.f64 (neg.f64 (*.f64 (+.f64 t y) (-.f64 y t))) (neg.f64 (+.f64 t y)))
(/.f64 (neg.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (neg.f64 (fma.f64 t (+.f64 t y) (*.f64 y y))))
(/.f64 (*.f64 (+.f64 t y) (-.f64 y t)) (+.f64 t y))
(/.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 t (+.f64 t y) (*.f64 y y)))
(cbrt.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 y y) (+.f64 t y)) (/.f64 (.f64 t t) (+.f64 t y)))
(-.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 t (+.f64 t y) (.f64 y y))) (/.f64 (pow.f64 t #s(literal 3 binary64)) (fma.f64 t (+.f64 t y) (.f64 y y))))
(-.f64 y t)
(exp.f64 (*.f64 (log.f64 (-.f64 y t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 y t)))
(+.f64 (cosh.f64 (.f64 (log.f64 (-.f64 y t)) #s(literal 1 binary64))) (sinh.f64 (.f64 (log.f64 (-.f64 y t)) #s(literal 1 binary64))))
(+.f64 (cosh.f64 (log.f64 (-.f64 y t))) (sinh.f64 (log.f64 (-.f64 y t))))
(+.f64 y (neg.f64 t))
(log.f64 (exp.f64 (-.f64 y t)))
x

eval154.0ms (2.3%)

Memory: 4.5MiB live, 196.2MiB allocated; 35ms collecting garbage
Compiler: Compiled 21 896 to 3 324 computations (84.8% saved)

prune27.0ms (0.4%)

Memory

-17.4MiB live, 71.6MiB allocated; 14ms collecting garbage

Pruning

17 alts after pruning (14 fresh and 3 done)

	Pruned	Kept	Total
New	815	10	825
Fresh	4	4	8
Picked	2	3	5
Done	0	0	0
Total	821	17	838

Accuracy

100.0%

Counts

838 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
	73.0%	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
	68.1%	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
▶	97.9%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
	53.6%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
	61.8%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
	62.4%	(-.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t))))
	61.3%	(-.f64 #s(literal 1 binary64) #s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z)))
✓	82.0%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
▶	59.5%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
▶	59.5%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
	82.5%	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
	77.9%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
✓	79.0%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
▶	53.2%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
	78.9%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x #s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y)))) #s(literal 1 binary64)))
▶	16.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
✓	74.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Compiler

Compiled 632 to 453 computations (28.3% saved)

simplify171.0ms (2.6%)

Memory

5.3MiB live, 201.8MiB allocated; 43ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(/.f64 (neg.f64 x) t)
cost-diff	0	(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
cost-diff	0	#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
cost-diff	0	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
cost-diff	0	(/.f64 x z)
cost-diff	0	(/.f64 (/.f64 x z) (-.f64 y t))
cost-diff	0	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
cost-diff	0	(/.f64 (neg.f64 x) (*.f64 t y))
cost-diff	0	#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
cost-diff	0	#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
cost-diff	0	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
cost-diff	0	(*.f64 #s(approx (- y t) y) z)
cost-diff	0	(/.f64 x (*.f64 #s(approx (- y t) y) z))
cost-diff	0	(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
cost-diff	0	#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
cost-diff	0	(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
cost-diff	6	(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)

Iterations

Useful iterations: 5 (0.0ms)

Iter	Nodes	Cost
0	44	381
0	66	381
1	99	381
2	141	381
3	237	373
4	425	365
5	1100	357
6	5115	357
0	8469	357

Stop Event

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

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
#s(literal 1 binary64)
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))
x
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)
(fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t)))
(/.f64 (-.f64 y t) z)
(-.f64 y t)
y
t
z
(neg.f64 (-.f64 y t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 #s(approx (- y t) y) z))
x
(*.f64 #s(approx (- y t) y) z)
#s(approx (- y t) y)
y
z
#s(literal 1 binary64)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
(/.f64 (neg.f64 x) (*.f64 t y))
(neg.f64 x)
x
(*.f64 t y)
t
y
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 x z)
x
z
(-.f64 y t)
y
t
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
(/.f64 (neg.f64 x) t)
(neg.f64 x)
x
t
#s(approx (- y z) y)
y

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) (-.f64 y z)))))
#s(literal 1 binary64)
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) (-.f64 y z))))
x
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) (-.f64 y z)))
(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)
(*.f64 (-.f64 y t) (-.f64 y z))
(fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t)))
(*.f64 (+.f64 (/.f64 (neg.f64 y) z) #s(literal 1 binary64)) (neg.f64 (-.f64 y t)))
(/.f64 (-.f64 y t) z)
(-.f64 y t)
y
t
z
(neg.f64 (-.f64 y t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal -1 binary64)))
(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(-.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal -1 binary64))
(/.f64 x (*.f64 #s(approx (- y t) y) z))
x
(*.f64 #s(approx (- y t) y) z)
#s(approx (- y t) y)
y
z
#s(literal 1 binary64)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 x y) (neg.f64 t)))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 x y) (neg.f64 t))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 x y) (neg.f64 t)))
(/.f64 (neg.f64 x) (*.f64 t y))
(/.f64 (/.f64 x y) (neg.f64 t))
(neg.f64 x)
x
(*.f64 t y)
t
y
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 x (*.f64 (-.f64 y t) z))
(/.f64 x z)
x
z
(-.f64 y t)
y
t
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x #s(approx (- y z) y)) (neg.f64 t))))
#s(literal 1 binary64)
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x #s(approx (- y z) y)) (neg.f64 t)))
(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
(/.f64 (/.f64 x #s(approx (- y z) y)) (neg.f64 t))
(/.f64 (neg.f64 x) t)
(neg.f64 x)
x
t
#s(approx (- y z) y)
y

localize176.0ms (2.6%)

Memory

-5.8MiB live, 285.8MiB allocated; 28ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.0	(neg.f64 x)
accuracy	3.482823520501477	(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
accuracy	22.764505278378802	#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
accuracy	31.14001076934607	#s(approx (- y z) y)
accuracy	0.0	(-.f64 y t)
accuracy	4.164610190982915	(/.f64 (/.f64 x z) (-.f64 y t))
accuracy	13.417333449338617	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
accuracy	40.06044529925059	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
accuracy	0.0	(neg.f64 x)
accuracy	4.686011610495564	(/.f64 (neg.f64 x) (*.f64 t y))
accuracy	22.764505278378802	#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
accuracy	28.37965045460721	#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
accuracy	0.0234375	(*.f64 #s(approx (- y t) y) z)
accuracy	4.504042484664614	(/.f64 x (*.f64 #s(approx (- y t) y) z))
accuracy	13.417333449338617	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
accuracy	34.128689981487206	#s(approx (- y t) y)
accuracy	0.02734375	(/.f64 (-.f64 y t) z)
accuracy	1.2017181509536576	(fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t)))
accuracy	4.254608252653648	(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)
accuracy	6.514129329070754	(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))

Samples

70.0ms

256×

valid

Compiler

Compiled 232 to 27 computations (88.4% saved)

Precisions

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

ival-mult: 15.0ms (40.4% of total)

ival-div: 13.0ms (35% of total)

ival-sub: 4.0ms (10.8% of total)

ival-add: 2.0ms (5.4% of total)

ival-neg: 2.0ms (5.4% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series90.0ms (1.3%)

Memory

-6.7MiB live, 138.8MiB allocated; 22ms collecting garbage

Counts

26 → 237

Calls

Call 1

Inputs
(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 #s(approx (- y t) y) z))
(*.f64 #s(approx (- y t) y) z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
(/.f64 (neg.f64 x) (*.f64 t y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 x z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
(/.f64 (neg.f64 x) t)
(fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t)))
(/.f64 (-.f64 y t) z)
#s(approx (- y t) y)
(neg.f64 x)
(-.f64 y t)
#s(approx (- y z) y)

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (neg x) (* t y)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x z) #s(hole binary64 (/ x z)))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (/ t z))))
#s(approx (/ (- y t) z) #s(hole binary64 (+ (* -1 (/ t z)) (/ y z))))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (/ (- y t) z) #s(hole binary64 (/ y z)))
#s(approx (/ (- y t) z) #s(hole binary64 (* y (+ (* -1 (/ t (* y z))) (/ 1 z)))))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* y (- (/ t (* y z)) (/ 1 z))))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (/ (- y t) z) #s(hole binary64 (/ (- y t) z)))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* t (- (/ y (* t z)) (/ 1 z)))))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ y (* t z))) (/ 1 z))))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Calls

12 calls:

Time	Variable		Point	Expression
29.0ms	t	@	0	((* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) (* t y)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x z) (- y t)) (/ x z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (+ (* (/ (- y t) z) y) (neg (- y t))) (/ (- y t) z) (- y t) (neg x) (- y t) (- y z))
19.0ms	x	@	inf	((* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) (* t y)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x z) (- y t)) (/ x z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (+ (* (/ (- y t) z) y) (neg (- y t))) (/ (- y t) z) (- y t) (neg x) (- y t) (- y z))
11.0ms	y	@	0	((* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) (* t y)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x z) (- y t)) (/ x z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (+ (* (/ (- y t) z) y) (neg (- y t))) (/ (- y t) z) (- y t) (neg x) (- y t) (- y z))
4.0ms	x	@	-inf	((* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) (* t y)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x z) (- y t)) (/ x z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (+ (* (/ (- y t) z) y) (neg (- y t))) (/ (- y t) z) (- y t) (neg x) (- y t) (- y z))
4.0ms	y	@	-inf	((* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) (* t y)) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x z) (- y t)) (/ x z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (/ (/ (neg x) t) (- y z)) (/ (neg x) t) (+ (* (/ (- y t) z) y) (neg (- y t))) (/ (- y t) z) (- y t) (neg x) (- y t) (- y z))

simplify224.0ms (3.3%)

Memory

3.1MiB live, 251.1MiB allocated; 108ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1092	6875
1	3332	6620
0	8709	6448

Stop Event

1×	iter limit
1×	node limit

Counts

237 → 237

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (neg x) (* t y)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x z) #s(hole binary64 (/ x z)))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (/ t z))))
#s(approx (/ (- y t) z) #s(hole binary64 (+ (* -1 (/ t z)) (/ y z))))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (/ (- y t) z) #s(hole binary64 (/ y z)))
#s(approx (/ (- y t) z) #s(hole binary64 (* y (+ (* -1 (/ t (* y z))) (/ 1 z)))))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* y (- (/ t (* y z)) (/ 1 z))))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (/ (- y t) z) #s(hole binary64 (/ (- y t) z)))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* t (- (/ y (* t z)) (/ 1 z)))))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ y (* t z))) (/ 1 z))))))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 (-.f64 y t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
#s(approx (/ (neg x) (* t y)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (neg x) (* t y)) (/.f64 (/.f64 (neg.f64 x) t) y))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 (-.f64 y t) z)))
#s(approx (/ x z) #s(hole binary64 (/ x z)))
#s(approx (/ x z) (/.f64 x z))
#s(approx (/ (neg x) t) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ (neg x) t) (/.f64 (neg.f64 x) t))
#s(approx (neg x) #s(hole binary64 (* -1 x)))
#s(approx (neg x) (neg.f64 x))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y t) (-.f64 y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (-.f64 y t) z)) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (*.f64 (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 x)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 z t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (.f64 z y) (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) (.f64 z t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (fma.f64 (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) z y) y (*.f64 z t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 t t)) (/.f64 x (*.f64 z z)) #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (.f64 (.f64 z z) (*.f64 t t)))) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 z t)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 (/.f64 x t) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (*.f64 z z)) (/.f64 (/.f64 x t) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 z t)) (.f64 (.f64 z z) (*.f64 t t))))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 z t)) (*.f64 z z)))) y (/.f64 (/.f64 x t) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) (*.f64 z t))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 (+.f64 z t)) y (*.f64 z t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (fma.f64 #s(literal -1 binary64) (+.f64 z t) y) y (*.f64 z t)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (/.f64 x t) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 3 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 4 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (neg.f64 x) t) z))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 3 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 4 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 z) t))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 x t) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (/ x (* t z)) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (/.f64 x (*.f64 z z)) (/.f64 y t) (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (/ x (* t (pow z 2))) (/ (* x y) (* t (pow z 3))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (/.f64 x (pow.f64 z #s(literal 3 binary64))) (/.f64 y t) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* y (+ (* y (+ (/ x (* t (pow z 3))) (/ (* x y) (* t (pow z 4))))) (/ x (* t (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 x (pow.f64 z #s(literal 4 binary64))) (/.f64 y t) (/.f64 x (.f64 (pow.f64 z #s(literal 3 binary64)) t))) y (/.f64 x (.f64 (*.f64 z z) t))) y (/.f64 (/.f64 x t) z)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (neg.f64 x) t) z))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 3 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 x (pow.f64 t #s(literal 4 binary64))) (/.f64 y (neg.f64 z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (*.f64 t t) z))) y (/.f64 (/.f64 (neg.f64 x) t) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) y t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (-.f64 (/.f64 (fma.f64 #s(literal -1 binary64) t y) z) #s(literal 1 binary64)) y t))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (/ t z))))
#s(approx (/ (- y t) z) (/.f64 (neg.f64 t) z))
#s(approx (/ (- y t) z) #s(hole binary64 (+ (* -1 (/ t z)) (/ y z))))
#s(approx (/ (- y t) z) (/.f64 (fma.f64 #s(literal -1 binary64) t y) z))
#s(approx (- y t) #s(hole binary64 (* -1 t)))
#s(approx (- y t) (neg.f64 t))
#s(approx (- y t) #s(hole binary64 (- y t)))
#s(approx (- y t) (-.f64 y t))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) (neg.f64 z))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y z) (-.f64 y z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 y y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (+.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64))) (.f64 (/.f64 z y) (/.f64 t y))) (*.f64 y y)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 z t)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 x (.f64 #s(literal 1 binary64) (/.f64 (+.f64 z t) y)) x) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) y) x) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y)) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 (+.f64 z t)) (.f64 (.f64 x t) (.f64 (neg.f64 (+.f64 z t)) z)))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) (*.f64 y y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) (.f64 (neg.f64 (+.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (* (- y z) (- y t)) (.f64 (+.f64 (fma.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64) (.f64 (/.f64 z y) (/.f64 t y))) #s(literal 1 binary64)) (*.f64 y y)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 x (*.f64 z y)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (fma.f64 (/.f64 x y) (/.f64 t y) (/.f64 x y)) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (+.f64 (/.f64 (+.f64 (/.f64 (.f64 (.f64 t t) x) (pow.f64 y #s(literal 3 binary64))) (/.f64 x y)) z) #s(literal 1 binary64)) (.f64 (/.f64 t (.f64 y y)) (/.f64 (neg.f64 x) z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 z y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (+.f64 (/.f64 (*.f64 x t) y) x) z) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 x y) (/.f64 (.f64 t t) y) x) z) (.f64 (/.f64 (neg.f64 t) y) (/.f64 x z))) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 t y) #s(literal 3 binary64)) (/.f64 x z) (/.f64 x z)) (neg.f64 (/.f64 (+.f64 (/.f64 (.f64 x t) y) (.f64 (/.f64 x y) (/.f64 (*.f64 t t) y))) z))) y))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) (*.f64 z y))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 t) (/.f64 z y) z) y))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ x (* t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (/.f64 (neg.f64 x) t) y))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 x t) #s(literal -1 binary64) (neg.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x (.f64 y y)) (*.f64 (/.f64 z t) (/.f64 x y))))) y))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (+ (* -1 (/ (* x z) (* t y))) (+ (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x (pow z 3)) (* t (pow y 3))))))) y)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 #s(literal -1 binary64) (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 (fma.f64 (pow.f64 (/.f64 z y) #s(literal 3 binary64)) (/.f64 x t) (.f64 (/.f64 (.f64 z z) t) (/.f64 x (*.f64 y y)))))) y))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 z y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (+.f64 (/.f64 (*.f64 x t) y) x) z) y))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 x y) (/.f64 (.f64 t t) y) x) z) (.f64 (/.f64 (neg.f64 t) y) (/.f64 x z))) y))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 t y) #s(literal 3 binary64)) (/.f64 x z) (/.f64 x z)) (neg.f64 (/.f64 (+.f64 (/.f64 (.f64 x t) y) (.f64 (/.f64 x y) (/.f64 (*.f64 t t) y))) z))) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (/.f64 (*.f64 y y) z))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) (.f64 y y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (-.f64 (-.f64 (+.f64 (/.f64 t (.f64 y y)) (/.f64 #s(literal 1 binary64) z)) (/.f64 #s(literal 1 binary64) y)) (/.f64 (/.f64 t y) z)) (*.f64 y y)))
#s(approx (/ (- y t) z) #s(hole binary64 (/ y z)))
#s(approx (/ (- y t) z) (/.f64 y z))
#s(approx (/ (- y t) z) #s(hole binary64 (* y (+ (* -1 (/ t (* y z))) (/ 1 z)))))
#s(approx (/ (- y t) z) (*.f64 (fma.f64 (/.f64 (/.f64 t y) z) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) y))
#s(approx (- y t) #s(hole binary64 y))
#s(approx (- y t) y)
#s(approx (- y t) #s(hole binary64 (* y (+ 1 (* -1 (/ t y))))))
#s(approx (- y t) (*.f64 (fma.f64 (/.f64 t y) #s(literal -1 binary64) #s(literal 1 binary64)) y))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) y)
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 z y) #s(literal -1 binary64) #s(literal 1 binary64)) y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) z (.f64 t (/.f64 (neg.f64 z) y))) y) #s(literal -1 binary64) #s(literal 1 binary64)) (*.f64 y y)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 z t) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 z t) x (/.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) (neg.f64 y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 x (/.f64 (+.f64 z t) y) x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))) y) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 z t) z) x) t (.f64 (+.f64 z t) (fma.f64 (.f64 x t) z (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (neg.f64 x))))) y) (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) x)) (.f64 (.f64 x z) t)) (neg.f64 y)) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (neg.f64 (+.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (neg.f64 t) (/.f64 z y) z) t) y) #s(literal -1 binary64) #s(literal 1 binary64)) (.f64 y y)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (*.f64 x t) y) x) z)) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 x t (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (*.f64 x t) y) x) z)) (neg.f64 y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 x t (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t (/.f64 x z) (/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y)) z)) (neg.f64 y))) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 y) (fma.f64 t (/.f64 z y) (neg.f64 z))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x z) (* t y))) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow z 2)) (* t y))) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) t) (/.f64 (.f64 z z) y)) (/.f64 (*.f64 x z) t)) (neg.f64 y)) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow z 3)) (* t y)) (* -1 (/ (* x (pow z 2)) t))) y)) (/ (* x z) t)) y)) (/ x t)) y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 z #s(literal 3 binary64)) t) (/.f64 x y) (.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 z z) x) t))) (neg.f64 y)) (/.f64 (.f64 x z) t)) (neg.f64 y)) (/.f64 x t)) (neg.f64 y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (*.f64 x t) y) x) z)) (neg.f64 y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 x t (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t (/.f64 x z) (/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y)) z)) (neg.f64 y))) y) (/.f64 x z))) (neg.f64 y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (/.f64 t y) #s(literal -1 binary64) (/.f64 t z)) #s(literal 1 binary64)) y) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) (.f64 y y)))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* y (- (/ t (* y z)) (/ 1 z))))))
#s(approx (/ (- y t) z) (*.f64 (neg.f64 y) (-.f64 (/.f64 (/.f64 t y) z) (/.f64 #s(literal 1 binary64) z))))
#s(approx (- y t) #s(hole binary64 (* -1 (* y (- (/ t y) 1)))))
#s(approx (- y t) (*.f64 (neg.f64 y) (-.f64 (/.f64 t y) #s(literal 1 binary64))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y z) (*.f64 (neg.f64 y) (-.f64 (/.f64 z y) #s(literal 1 binary64))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 y t) y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (-.f64 t y) z (*.f64 (-.f64 y t) y)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (.f64 y y)) (/.f64 x (-.f64 y t)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (/.f64 (.f64 x z) (pow.f64 y #s(literal 3 binary64)))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (/.f64 (.f64 x z) (pow.f64 y #s(literal 4 binary64)))) (-.f64 y t))) z (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 x y) (/.f64 z y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (-.f64 (.f64 (/.f64 z (pow.f64 y #s(literal 3 binary64))) (/.f64 x (-.f64 y t))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y t))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 z (-.f64 y t)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 z) (-.f64 y t) (*.f64 (-.f64 y t) y)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (+.f64 (/.f64 x (-.f64 y t)) z) z))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (* (- y t) z) (*.f64 (-.f64 y t) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ (/ (neg x) t) (- y z)) (neg.f64 (fma.f64 x (/.f64 z (.f64 (.f64 y y) t)) (/.f64 x (*.f64 t y)))))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* -1 (/ (* x z) (* t (pow y 3)))))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (neg.f64 (fma.f64 x (/.f64 z (.f64 (pow.f64 y #s(literal 3 binary64)) t)) (/.f64 x (.f64 (*.f64 y y) t)))) z (/.f64 (/.f64 (neg.f64 x) t) y)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (+ (* -1 (/ x (* t y))) (* z (+ (* -1 (/ x (* t (pow y 2)))) (* z (+ (* -1 (/ x (* t (pow y 3)))) (* -1 (/ (* x z) (* t (pow y 4)))))))))))
#s(approx (/ (/ (neg x) t) (- y z)) (fma.f64 (fma.f64 (neg.f64 (fma.f64 x (/.f64 z (.f64 (pow.f64 y #s(literal 4 binary64)) t)) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) t)))) z (/.f64 (/.f64 (neg.f64 x) t) (*.f64 y y))) z (/.f64 (/.f64 (neg.f64 x) t) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (/.f64 (-.f64 y t) z) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (/.f64 (fma.f64 (-.f64 t y) z (*.f64 (-.f64 y t) y)) z))
#s(approx (/ (- y t) z) #s(hole binary64 (/ (- y t) z)))
#s(approx (/ (- y t) z) (/.f64 (-.f64 y t) z))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- y z) (fma.f64 #s(literal -1 binary64) z y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 t y) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 (fma.f64 (/.f64 (-.f64 y t) z) y t) y) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (/.f64 x (*.f64 z z)) (/.f64 y (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) (-.f64 y t)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) (-.f64 y t)) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) (-.f64 y t)) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (*.f64 x (/.f64 y z))) (-.f64 y t))) z))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 z) (-.f64 y t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t)) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (*.f64 (/.f64 y t) (/.f64 x z))) (/.f64 x t)) z))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (/ (+ (/ x t) (+ (/ (* x y) (* t z)) (+ (/ (* x (pow y 2)) (* t (pow z 2))) (/ (* x (pow y 3)) (* t (pow z 3)))))) z)))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (+.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (*.f64 (pow.f64 (/.f64 y z) #s(literal 3 binary64)) (/.f64 x t)))) (/.f64 x t)) z))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 t y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 (fma.f64 (/.f64 (-.f64 y t) z) y t) y))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- y z) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (neg.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 t y))) (neg.f64 z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (-.f64 (*.f64 (/.f64 (neg.f64 x) z) (/.f64 y (-.f64 y t))) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 x y)) (-.f64 y t)) (neg.f64 z)) (/.f64 x (-.f64 y t))) (neg.f64 z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t)) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) (-.f64 y t)) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (/.f64 (.f64 (.f64 y y) x) (neg.f64 (-.f64 y t)))) (neg.f64 z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) (neg.f64 z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 (fma.f64 (neg.f64 y) (/.f64 (-.f64 y t) z) y) t) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t))) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x y) t) (/ (* x (pow y 2)) (* t z))) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x z) (/.f64 (.f64 x y) t)) z) (/.f64 x t))) (neg.f64 z)))
#s(approx (/ (/ (neg x) t) (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow y 2)) t)) (* -1 (/ (* x (pow y 3)) (* t z)))) z)) (/ (* x y) t)) z))) z))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 x (/.f64 y t) (/.f64 (neg.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) t))) (neg.f64 z))) z) (/.f64 x t))) (neg.f64 z)))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) (neg.f64 z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (-.f64 (/.f64 (.f64 y y) z) y) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (-.f64 (/.f64 (.f64 y y) z) y) z (.f64 (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z) t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (/.f64 (.f64 x t) (pow.f64 y #s(literal 3 binary64)))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (/.f64 (.f64 x t) (pow.f64 y #s(literal 4 binary64)))) (-.f64 y z))) t (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 x y) (/.f64 t y) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (/.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y z) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 t) (-.f64 y z) (*.f64 (-.f64 y z) y)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 4 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (fma.f64 (/.f64 x y) (/.f64 t y) (/.f64 x y)) z))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 4 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (fma.f64 (/.f64 x y) (/.f64 t y) (/.f64 x y)) z))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 4 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 (/.f64 (*.f64 y y) z) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) t (-.f64 (/.f64 (*.f64 y y) z) y)))
#s(approx (- y t) #s(hole binary64 (+ y (* -1 t))))
#s(approx (- y t) (fma.f64 #s(literal -1 binary64) t y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z) t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z (/.f64 (.f64 (-.f64 (/.f64 (*.f64 y y) z) y) z) t)) t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (fma.f64 (/.f64 y (*.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 x y) t)) (-.f64 y z))) t))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 t) (-.f64 y z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 y (/.f64 (-.f64 y z) t) (neg.f64 (-.f64 y z))) t))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) z) #s(literal 1 binary64)) (.f64 (/.f64 y (.f64 t t)) (/.f64 x z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) z)) (*.f64 (/.f64 y t) (/.f64 x z))) t))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) (pow.f64 t #s(literal 3 binary64)))) z)) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 x y) t)) z)) t))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 y (/.f64 z t) (neg.f64 z)) t))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) z)) (*.f64 (/.f64 y t) (/.f64 x z))) t))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (/.f64 (.f64 (pow.f64 y #s(literal 3 binary64)) x) (pow.f64 t #s(literal 3 binary64)))) z)) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 x y) t)) z)) t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (-.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1 binary64) y (/.f64 (.f64 y y) t)) z) #s(literal 1 binary64)) (/.f64 y t)) t))
#s(approx (/ (- y t) z) #s(hole binary64 (* t (- (/ y (* t z)) (/ 1 z)))))
#s(approx (/ (- y t) z) (*.f64 (-.f64 (/.f64 (/.f64 y t) z) (/.f64 #s(literal 1 binary64) z)) t))
#s(approx (- y t) #s(hole binary64 (* t (- (/ y t) 1))))
#s(approx (- y t) (*.f64 (-.f64 (/.f64 y t) #s(literal 1 binary64)) t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z) (neg.f64 t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z (.f64 (neg.f64 z) (/.f64 (-.f64 (/.f64 (*.f64 y y) z) y) t))) (neg.f64 t)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (-.f64 (*.f64 (/.f64 (neg.f64 x) t) (/.f64 y (-.f64 y z))) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (-.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 x y)) (-.f64 y z)) (neg.f64 t)) (/.f64 x (-.f64 y z))) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z)) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) t) (/.f64 (.f64 y y) (-.f64 y z)) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (.f64 y y) x) (neg.f64 (-.f64 y z)))) (neg.f64 t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) (neg.f64 t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 (fma.f64 (neg.f64 y) (/.f64 (-.f64 y z) t) y) z) (neg.f64 t)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) t) (/.f64 (.f64 y y) z)) (*.f64 x (/.f64 y z))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) t) (/.f64 (.f64 y y) z)) (*.f64 x (/.f64 y z))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (.f64 x (/.f64 (.f64 y y) z)))) (neg.f64 t)) (.f64 x (/.f64 y z))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 y) (/.f64 z t) z) (neg.f64 t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) (neg.f64 t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) t) (/.f64 (.f64 y y) z)) (*.f64 x (/.f64 y z))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (/ (/ x z) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (.f64 x (/.f64 (.f64 y y) z)))) (neg.f64 t)) (.f64 x (/.f64 y z))) (neg.f64 t)) (/.f64 x z)) (neg.f64 t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (.f64 y y) z) y) t) #s(literal -1 binary64) (-.f64 (/.f64 y z) #s(literal 1 binary64))) (neg.f64 t)))
#s(approx (/ (- y t) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ y (* t z))) (/ 1 z))))))
#s(approx (/ (- y t) z) (*.f64 (fma.f64 (/.f64 (/.f64 y t) z) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) (neg.f64 t)))
#s(approx (- y t) #s(hole binary64 (* -1 (* t (+ 1 (* -1 (/ y t)))))))
#s(approx (- y t) (*.f64 (fma.f64 (/.f64 y t) #s(literal -1 binary64) #s(literal 1 binary64)) (neg.f64 t)))

rewrite156.0ms (2.3%)

Memory

7.0MiB live, 151.3MiB allocated; 40ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	44	348
0	66	348
1	750	331
0	8323	331

Stop Event

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

Counts

26 → 504

Calls

Call 1

Inputs
(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z)))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(/.f64 x (*.f64 #s(approx (- y t) y) z))
(*.f64 #s(approx (- y t) y) z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y))))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))
(/.f64 (neg.f64 x) (*.f64 t y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t)))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 x z)
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y)))
(/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))
(/.f64 (neg.f64 x) t)
(fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t)))
(/.f64 (-.f64 y t) z)
#s(approx (- y t) y)
(neg.f64 x)
(-.f64 y t)
#s(approx (- y z) y)

Outputs
(.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) (neg.f64 (sqrt.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(.f64 (sqrt.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) (sqrt.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))
(.f64 (pow.f64 (cbrt.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 2 binary64)) (cbrt.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))
(*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)
(*.f64 z (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)))
(pow.f64 (sqrt.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 3 binary64))
(pow.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z) #s(literal 1 binary64))
(cbrt.f64 (*.f64 (pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))
(+.f64 (cosh.f64 (log.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) (sinh.f64 (log.f64 (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(log.f64 (pow.f64 (exp.f64 z) (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))))
(.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))))
(.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(pow.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) (/.f64 (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))) (/.f64 (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(exp.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) (/.f64 (cbrt.f64 x) (sqrt.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) (neg.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(pow.f64 (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 3 binary64))
(pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 1 binary64))
(/.f64 x (neg.f64 (neg.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(/.f64 x (neg.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))
(cbrt.f64 (.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(exp.f64 (.f64 (log.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))) (sinh.f64 (log.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))))
(log.f64 (exp.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (neg.f64 (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) (neg.f64 (sqrt.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(.f64 (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) (sqrt.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(.f64 (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64)) (cbrt.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(pow.f64 (sqrt.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 3 binary64))
(pow.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 1 binary64))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))
(cbrt.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(+.f64 (cosh.f64 (log.f64 #s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))) (sinh.f64 (log.f64 #s(approx ( (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z)))))
(log.f64 (exp.f64 #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) z))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(.f64 (neg.f64 (sqrt.f64 (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))) (neg.f64 (sqrt.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(.f64 (sqrt.f64 (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) (sqrt.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))
(.f64 (pow.f64 (cbrt.f64 (+.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (cbrt.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))
(pow.f64 (sqrt.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) #s(literal 3 binary64))
(pow.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 3 binary64)) #s(literal 1 binary64))) (neg.f64 (+.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(/.f64 (+.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) #s(approx (- y t) y)) (/.f64 (sqrt.f64 x) z) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) #s(approx (- y t) y)) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 #s(approx (- y t) y) z))) (/.f64 (cbrt.f64 x) (sqrt.f64 (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) #s(approx (- y t) y)) (/.f64 (cbrt.f64 x) z) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) #s(approx (- y t) y)) #s(literal 1 binary64))
(fma.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))) (neg.f64 (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64))
(cbrt.f64 (pow.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) (-.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))
(exp.f64 (.f64 (log1p.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64)))
(exp.f64 (log1p.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(+.f64 (cosh.f64 (log1p.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))) (sinh.f64 (log1p.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))))
(+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (/.f64 x (*.f64 #s(approx (- y t) y) z)))
(log.f64 (exp.f64 (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 #s(approx (- y t) y) z))))
(*.f64 (/.f64 (sqrt.f64 x) #s(approx (- y t) y)) (/.f64 (sqrt.f64 x) z))
(*.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) #s(approx (- y t) y)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 #s(approx (- y t) y) z))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 #s(approx (- y t) y) z))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) #s(approx (- y t) y)) (/.f64 (cbrt.f64 x) z))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) #s(approx (- y t) y)))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)))))
(.f64 (sqrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) (sqrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64))
(/.f64 (neg.f64 (/.f64 x #s(approx (- y t) y))) (neg.f64 z))
(/.f64 (/.f64 x #s(approx (- y t) y)) z)
(/.f64 x (neg.f64 (neg.f64 (*.f64 #s(approx (- y t) y) z))))
(/.f64 x (neg.f64 (*.f64 #s(approx (- y t) y) z)))
(/.f64 x (*.f64 #s(approx (- y t) y) z))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 #s(approx (- y t) y) z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))) (sinh.f64 (log.f64 (/.f64 x (.f64 #s(approx (- y t) y) z)))))
(log.f64 (exp.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z))))
(.f64 (neg.f64 (sqrt.f64 (.f64 #s(approx (- y t) y) z))) (neg.f64 (sqrt.f64 (*.f64 #s(approx (- y t) y) z))))
(.f64 (sqrt.f64 (.f64 #s(approx (- y t) y) z)) (sqrt.f64 (*.f64 #s(approx (- y t) y) z)))
(.f64 (pow.f64 (cbrt.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64)) (cbrt.f64 (*.f64 #s(approx (- y t) y) z)))
(*.f64 #s(approx (- y t) y) z)
(*.f64 z #s(approx (- y t) y))
(pow.f64 (sqrt.f64 (*.f64 #s(approx (- y t) y) z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(approx (- y t) y) z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 #s(approx (- y t) y) z)) #s(literal 3 binary64))
(pow.f64 (*.f64 #s(approx (- y t) y) z) #s(literal 1 binary64))
(cbrt.f64 (*.f64 (pow.f64 #s(approx (- y t) y) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 #s(approx (- y t) y) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 #s(approx (- y t) y) z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 #s(approx (- y t) y) z) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (*.f64 #s(approx (- y t) y) z)))
(+.f64 (cosh.f64 (log.f64 (.f64 #s(approx (- y t) y) z))) (sinh.f64 (log.f64 (.f64 #s(approx (- y t) y) z))))
(log.f64 (pow.f64 (exp.f64 z) #s(approx (- y t) y)))
(.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))))
(.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))))) (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(pow.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))))) (/.f64 (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))))) (/.f64 (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(exp.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))))
(log.f64 (/.f64 (E.f64) (exp.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))))) (neg.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))) (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(pow.f64 (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 3 binary64))
(pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 1 binary64))
#s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))
(cbrt.f64 (.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(exp.f64 (.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))))) (sinh.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))))
(log.f64 (exp.f64 #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))) (neg.f64 (sqrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))))))
(.f64 (sqrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) (sqrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(pow.f64 (sqrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))) #s(literal 3 binary64))
(pow.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))) #s(literal 1 binary64))
#s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))
(cbrt.f64 (pow.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(+.f64 (cosh.f64 (log.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))) (sinh.f64 (log.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (.f64 t y))))))
(log.f64 (exp.f64 #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 x (*.f64 t y)))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x t)) (pow.f64 (cbrt.f64 y) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x t)) (cbrt.f64 y)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (sqrt.f64 y)) (/.f64 (cbrt.f64 (/.f64 x t)) (sqrt.f64 y)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 y) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 t y))))
(*.f64 (/.f64 (sqrt.f64 x) t) (/.f64 (sqrt.f64 x) y))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) t) (/.f64 (cbrt.f64 x) y))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 t y)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 t y))))
(*.f64 (/.f64 (sqrt.f64 x) y) (/.f64 (sqrt.f64 x) t))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 t y))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 t y))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 t y)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 t y))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) y) (/.f64 (cbrt.f64 x) t))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 t y)))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 t y)))))
(.f64 (sqrt.f64 (/.f64 x (.f64 t y))) (sqrt.f64 (/.f64 x (*.f64 t y))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 t y))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 t y))))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 t y))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 t y)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 t y))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 t y)) #s(literal 1 binary64))
(/.f64 (/.f64 x t) (neg.f64 y))
(/.f64 (/.f64 x t) y)
(/.f64 x (neg.f64 (neg.f64 (*.f64 t y))))
(/.f64 x (neg.f64 (*.f64 t y)))
(/.f64 x (*.f64 t y))
(neg.f64 (/.f64 x (*.f64 t y)))
(cbrt.f64 (/.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)) (pow.f64 y #s(literal 3 binary64))))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 (*.f64 t y) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 t y)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 t y)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 t y))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 t y))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 t y)))) (sinh.f64 (log.f64 (/.f64 x (.f64 t y)))))
(log.f64 (exp.f64 (/.f64 x (*.f64 t y))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sqrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(pow.f64 (sqrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64))
(pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))
(cbrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sinh.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(log.f64 (exp.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x z)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x z)) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x z)) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 (/.f64 x z)) (sqrt.f64 (-.f64 y t))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x z)) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 z (-.f64 y t)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) z))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) z))
(*.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t))))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 1 binary64))
(/.f64 (neg.f64 (/.f64 x (-.f64 y t))) (neg.f64 z))
(/.f64 (neg.f64 (neg.f64 (/.f64 x z))) (-.f64 y t))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 (neg.f64 (/.f64 x z)) (-.f64 y t))
(/.f64 (/.f64 x z) (-.f64 y t))
(/.f64 x (neg.f64 (neg.f64 (*.f64 z (-.f64 y t)))))
(/.f64 x (neg.f64 (*.f64 z (-.f64 y t))))
(/.f64 x (*.f64 z (-.f64 y t)))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))) (sinh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))))
(log.f64 (exp.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 x) (sqrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x z)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x z))) (neg.f64 (sqrt.f64 (/.f64 x z))))
(*.f64 (sqrt.f64 (/.f64 x z)) (sqrt.f64 (/.f64 x z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x z)) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x z)))
(pow.f64 (sqrt.f64 (/.f64 x z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x z)) #s(literal 3 binary64))
(pow.f64 (/.f64 x z) #s(literal 1 binary64))
(/.f64 x (neg.f64 (neg.f64 z)))
(/.f64 x (neg.f64 z))
(/.f64 x z)
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x z) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x z)))
(+.f64 (cosh.f64 (log.f64 (/.f64 x z))) (sinh.f64 (log.f64 (/.f64 x z))))
(log.f64 (exp.f64 (/.f64 x z)))
(.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))))
(.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(pow.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) (/.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))) (/.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(exp.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))))
(log.f64 (/.f64 (E.f64) (exp.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) (neg.f64 (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(.f64 (sqrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(.f64 #s(literal 1 binary64) #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(pow.f64 (sqrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 3 binary64))
(pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 1 binary64))
#s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))
(cbrt.f64 (.f64 #s(literal 1 binary64) (pow.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(exp.f64 (.f64 (log.f64 #s(approx (/ x ( (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(+.f64 (cosh.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))) (sinh.f64 (log.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y))))))
(log.f64 (exp.f64 #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x t)) (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x t)) (cbrt.f64 #s(approx (- y z) y))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (sqrt.f64 #s(approx (- y z) y))) (/.f64 (cbrt.f64 (/.f64 x t)) (sqrt.f64 #s(approx (- y z) y))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(*.f64 (/.f64 (sqrt.f64 x) t) (/.f64 (sqrt.f64 x) #s(approx (- y z) y)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) t) (/.f64 (cbrt.f64 x) #s(approx (- y z) y)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))) (sqrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)) #s(literal 1 binary64))
(/.f64 (/.f64 x t) (neg.f64 (neg.f64 #s(approx (- y z) y))))
(/.f64 (/.f64 x t) (neg.f64 #s(approx (- y z) y)))
(/.f64 (/.f64 x t) #s(approx (- y z) y))
(/.f64 x (neg.f64 (*.f64 t #s(approx (- y z) y))))
(/.f64 x (*.f64 t #s(approx (- y z) y)))
(cbrt.f64 (/.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)) (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y)))))
(log.f64 (exp.f64 (/.f64 (/.f64 x t) #s(approx (- y z) y))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 t)) (/.f64 (cbrt.f64 x) (sqrt.f64 t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x t))) (neg.f64 (sqrt.f64 (/.f64 x t))))
(*.f64 (sqrt.f64 (/.f64 x t)) (sqrt.f64 (/.f64 x t)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x t)))
(pow.f64 (sqrt.f64 (/.f64 x t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x t)) #s(literal 3 binary64))
(pow.f64 (/.f64 x t) #s(literal 1 binary64))
(/.f64 x (neg.f64 (neg.f64 t)))
(/.f64 x (neg.f64 t))
(/.f64 x t)
(neg.f64 (/.f64 x t))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x t) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x t)))
(+.f64 (cosh.f64 (log.f64 (/.f64 x t))) (sinh.f64 (log.f64 (/.f64 x t))))
(log.f64 (exp.f64 (/.f64 x t)))
(*.f64 (neg.f64 (sqrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)))) (neg.f64 (sqrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)))))
(*.f64 (sqrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))) (sqrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))))
(*.f64 (pow.f64 (cbrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))) #s(literal 2 binary64)) (cbrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))))
(pow.f64 (sqrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))) #s(literal 3 binary64))
(pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 2 binary64)) (pow.f64 (-.f64 y t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)) (.f64 (.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t))))))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 2 binary64)) (pow.f64 (-.f64 y t) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t)))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 2 binary64)) (-.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)) (.f64 (.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t)))))
(fma.f64 (/.f64 (-.f64 y t) (sqrt.f64 z)) (/.f64 y (sqrt.f64 z)) (-.f64 y t))
(fma.f64 (/.f64 (-.f64 y t) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 y (cbrt.f64 z)) (-.f64 y t))
(fma.f64 (neg.f64 (sqrt.f64 (.f64 (/.f64 (-.f64 y t) z) y))) (neg.f64 (sqrt.f64 (.f64 (/.f64 (-.f64 y t) z) y))) (-.f64 y t))
(fma.f64 (neg.f64 (sqrt.f64 (-.f64 y t))) (neg.f64 (sqrt.f64 (-.f64 y t))) (*.f64 (/.f64 (-.f64 y t) z) y))
(fma.f64 (sqrt.f64 (.f64 (/.f64 (-.f64 y t) z) y)) (sqrt.f64 (.f64 (/.f64 (-.f64 y t) z) y)) (-.f64 y t))
(fma.f64 (sqrt.f64 (-.f64 y t)) (sqrt.f64 (-.f64 y t)) (*.f64 (/.f64 (-.f64 y t) z) y))
(fma.f64 (pow.f64 (cbrt.f64 (.f64 (/.f64 (-.f64 y t) z) y)) #s(literal 2 binary64)) (cbrt.f64 (.f64 (/.f64 (-.f64 y t) z) y)) (-.f64 y t))
(fma.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y t)) (*.f64 (/.f64 (-.f64 y t) z) y))
(fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))
(fma.f64 y (/.f64 (-.f64 y t) z) (-.f64 y t))
(cbrt.f64 (pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (.f64 (/.f64 (-.f64 y t) z) y) #s(literal 2 binary64)) (-.f64 (.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t))) (/.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)) (-.f64 (*.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t))))
(exp.f64 (*.f64 (log.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))))
(+.f64 (cosh.f64 (log.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)))) (sinh.f64 (log.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t)))))
(+.f64 (*.f64 (/.f64 (-.f64 y t) z) y) (-.f64 y t))
(+.f64 (-.f64 y t) (*.f64 (/.f64 (-.f64 y t) z) y))
(log.f64 (exp.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 (-.f64 y t)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (-.f64 y t)) (cbrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 (-.f64 y t)) (sqrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (-.f64 y t) z)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (-.f64 y t) z))) (neg.f64 (sqrt.f64 (/.f64 (-.f64 y t) z))))
(*.f64 (sqrt.f64 (/.f64 (-.f64 y t) z)) (sqrt.f64 (/.f64 (-.f64 y t) z)))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (-.f64 y t) z)) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (-.f64 y t) z)))
(pow.f64 (sqrt.f64 (/.f64 (-.f64 y t) z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (-.f64 y t) z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (-.f64 y t) z)) #s(literal 3 binary64))
(pow.f64 (/.f64 (-.f64 y t) z) #s(literal 1 binary64))
(/.f64 (-.f64 (.f64 y z) (.f64 z t)) (*.f64 z z))
(/.f64 (-.f64 y t) (neg.f64 (neg.f64 z)))
(/.f64 (-.f64 y t) (neg.f64 z))
(/.f64 (-.f64 y t) z)
(cbrt.f64 (/.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (-.f64 y t) z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (-.f64 y t) z) #s(literal 2 binary64)))
(-.f64 (/.f64 y z) (/.f64 t z))
(exp.f64 (*.f64 (log.f64 (/.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (-.f64 y t) z)))
(+.f64 (cosh.f64 (log.f64 (/.f64 (-.f64 y t) z))) (sinh.f64 (log.f64 (/.f64 (-.f64 y t) z))))
(log.f64 (exp.f64 (/.f64 (-.f64 y t) z)))
(*.f64 (neg.f64 (sqrt.f64 #s(approx (- y t) y))) (neg.f64 (sqrt.f64 #s(approx (- y t) y))))
(*.f64 (sqrt.f64 #s(approx (- y t) y)) (sqrt.f64 #s(approx (- y t) y)))
(*.f64 (pow.f64 (cbrt.f64 #s(approx (- y t) y)) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- y t) y)))
(pow.f64 (sqrt.f64 #s(approx (- y t) y)) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- y t) y) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- y t) y)) #s(literal 3 binary64))
(pow.f64 #s(approx (- y t) y) #s(literal 1 binary64))
#s(approx (- y t) y)
(cbrt.f64 (pow.f64 #s(approx (- y t) y) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- y t) y) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 #s(approx (- y t) y)) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- y t) y)))
(+.f64 (cosh.f64 (log.f64 #s(approx (- y t) y))) (sinh.f64 (log.f64 #s(approx (- y t) y))))
(log.f64 (exp.f64 #s(approx (- y t) y)))
x
(*.f64 (neg.f64 (sqrt.f64 (-.f64 y t))) (neg.f64 (sqrt.f64 (-.f64 y t))))
(*.f64 (sqrt.f64 (-.f64 y t)) (sqrt.f64 (-.f64 y t)))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (cbrt.f64 (-.f64 y t)))
(pow.f64 (sqrt.f64 (-.f64 y t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 3 binary64))
(pow.f64 (-.f64 y t) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 (.f64 y y) (.f64 t t))) (neg.f64 (+.f64 y t)))
(/.f64 (neg.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (neg.f64 (fma.f64 y y (fma.f64 t t (*.f64 t y)))))
(/.f64 (-.f64 (.f64 y y) (.f64 t t)) (+.f64 y t))
(/.f64 (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 y y (fma.f64 t t (*.f64 t y))))
(neg.f64 (-.f64 y t))
(cbrt.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 y t) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 y y) (+.f64 y t)) (/.f64 (.f64 t t) (+.f64 y t)))
(-.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) (fma.f64 y y (fma.f64 t t (.f64 t y)))) (/.f64 (pow.f64 t #s(literal 3 binary64)) (fma.f64 y y (fma.f64 t t (.f64 t y)))))
(-.f64 y t)
(exp.f64 (*.f64 (log.f64 (-.f64 y t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 y t)))
(+.f64 (cosh.f64 (log.f64 (-.f64 y t))) (sinh.f64 (log.f64 (-.f64 y t))))
(log.f64 (exp.f64 (-.f64 y t)))
(*.f64 (neg.f64 (sqrt.f64 #s(approx (- y z) y))) (neg.f64 (sqrt.f64 #s(approx (- y z) y))))
(*.f64 (sqrt.f64 #s(approx (- y z) y)) (sqrt.f64 #s(approx (- y z) y)))
(*.f64 (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- y z) y)))
(pow.f64 (sqrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 3 binary64))
(pow.f64 #s(approx (- y z) y) #s(literal 1 binary64))
#s(approx (- y z) y)
(cbrt.f64 (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- y z) y) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 #s(approx (- y z) y)) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- y z) y)))
(+.f64 (cosh.f64 (log.f64 #s(approx (- y z) y))) (sinh.f64 (log.f64 #s(approx (- y z) y))))
(log.f64 (exp.f64 #s(approx (- y z) y)))

eval198.0ms (2.9%)

Memory: 0.4MiB live, 189.8MiB allocated; 29ms collecting garbage
Compiler: Compiled 25 999 to 3 566 computations (86.3% saved)

prune55.0ms (0.8%)

Memory

-29.5MiB live, 61.2MiB allocated; 8ms collecting garbage

Pruning

16 alts after pruning (10 fresh and 6 done)

	Pruned	Kept	Total
New	753	4	757
Fresh	3	6	9
Picked	1	4	5
Done	1	2	3
Total	758	16	774

Accuracy

100.0%

Counts

774 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	73.0%	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
	68.1%	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
	70.2%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) (*.f64 (/.f64 (-.f64 y t) z) y)) z))))
▶	61.8%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
	53.6%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
	62.4%	(-.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t))))
	61.3%	(-.f64 #s(literal 1 binary64) #s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z)))
✓	82.0%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
✓	59.5%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
✓	59.5%	(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
▶	82.5%	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
✓	53.2%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
▶	16.0%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
✓	16.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
▶	17.1%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
✓	74.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Compiler

Compiled 570 to 390 computations (31.6% saved)

simplify163.0ms (2.4%)

Memory

11.4MiB live, 158.7MiB allocated; 18ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
cost-diff	0	#s(approx (- y z) y)
cost-diff	0	(/.f64 x #s(approx (- y z) y))
cost-diff	0	(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
cost-diff	0	(/.f64 x (-.f64 y t))
cost-diff	0	(/.f64 (/.f64 x (-.f64 y t)) z)
cost-diff	0	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
cost-diff	0	(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
cost-diff	0	#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
cost-diff	0	(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
cost-diff	0	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
cost-diff	0	(*.f64 (-.f64 y t) z)
cost-diff	0	(/.f64 x (*.f64 (-.f64 y t) z))
cost-diff	0	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
cost-diff	0	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
cost-diff	0	(*.f64 (-.f64 y z) t)
cost-diff	0	(/.f64 x (*.f64 (-.f64 y z) t))
cost-diff	0	(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
cost-diff	0	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))

Iterations

Useful iterations: 5 (0.0ms)

Iter	Nodes	Cost
0	43	335
0	60	335
1	82	335
2	99	335
3	137	335
4	235	335
5	705	330
6	5059	330
0	8495	330

Stop Event

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

Calls

Call 1

Inputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y z) t))
x
(*.f64 (-.f64 y z) t)
(-.f64 y z)
y
z
t
#s(literal 1 binary64)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
(/.f64 x (*.f64 (-.f64 y t) z))
x
(*.f64 (-.f64 y t) z)
(-.f64 y t)
y
t
z
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
#s(literal 1 binary64)
(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
x
#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
t
z
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (-.f64 y t))
x
(-.f64 y t)
y
t
z
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
#s(literal 1 binary64)
(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
(/.f64 x #s(approx (- y z) y))
x
#s(approx (- y z) y)
y
(-.f64 y t)
t

Outputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))
(/.f64 x (*.f64 (-.f64 y z) t))
x
(*.f64 (-.f64 y z) t)
(-.f64 y z)
y
z
t
#s(literal 1 binary64)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))
(/.f64 x (*.f64 (-.f64 y t) z))
(/.f64 x (*.f64 z (-.f64 y t)))
x
(*.f64 (-.f64 y t) z)
(*.f64 z (-.f64 y t))
(-.f64 y t)
y
t
z
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
#s(literal 1 binary64)
(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
x
#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
t
z
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (*.f64 z (-.f64 y t)))
(/.f64 x (-.f64 y t))
x
(-.f64 y t)
y
t
z
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
#s(literal 1 binary64)
(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
(/.f64 x #s(approx (- y z) y))
x
#s(approx (- y z) y)
y
(-.f64 y t)
t

localize112.0ms (1.7%)

Memory

6.9MiB live, 99.1MiB allocated; 7ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.0	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
accuracy	0.015625	(/.f64 x #s(approx (- y z) y))
accuracy	1.0971916031032294	(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
accuracy	31.14001076934607	#s(approx (- y z) y)
accuracy	0.01171875	(/.f64 x (-.f64 y t))
accuracy	4.9351922092738	(/.f64 (/.f64 x (-.f64 y t)) z)
accuracy	13.417333449338617	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
accuracy	40.06044529925059	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
accuracy	0.0	#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
accuracy	4.254608252653648	(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
accuracy	6.514129329070754	(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
accuracy	41.18600308143056	#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
accuracy	0.0234375	(*.f64 (-.f64 y t) z)
accuracy	4.504042484664614	(/.f64 x (*.f64 (-.f64 y t) z))
accuracy	13.417333449338617	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
accuracy	40.06044529925059	#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
accuracy	0.0	(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
accuracy	0.0078125	(*.f64 (-.f64 y z) t)
accuracy	5.594682519237397	(/.f64 x (*.f64 (-.f64 y z) t))
accuracy	11.137575557002995	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))

Samples

95.0ms

256×

valid

Compiler

Compiled 212 to 30 computations (85.8% saved)

Precisions

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

ival-sub: 34.0ms (56.7% of total)

ival-div: 14.0ms (23.4% of total)

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

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

ival-neg: 1.0ms (1.7% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series59.0ms (0.9%)

Memory

9.0MiB live, 71.8MiB allocated; 13ms collecting garbage

Counts

21 → 384

Calls

Call 1

Inputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y z) t))
(*.f64 (-.f64 y z) t)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
(/.f64 x (*.f64 (-.f64 y t) z))
(*.f64 (-.f64 y t) z)
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (-.f64 y t))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
(/.f64 x #s(approx (- y z) y))
#s(approx (- y z) y)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)

Outputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2)))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2)))))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2)))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2))))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2))))))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y z) t) #s(hole binary64 (+ (* -1 (* t z)) (* t y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* t y)) (/ (* x (pow z 2)) (* t (pow y 3))))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (/ x t) (/ (* x z) (* t y))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 3)) (* t (pow y 3)))) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (* (- y z) t) #s(hole binary64 (* t y)))
#s(approx (* (- y z) t) #s(hole binary64 (* y (+ t (* -1 (/ (* t z) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* y z))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow z 2)) t)) (* -1 (/ (* x (pow z 3)) (* t y)))) y)) (/ (* x z) t)) y))) y))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* y (+ (* -1 t) (/ (* t z) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* t (pow z 3)))))) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 2)) (* t (pow z 2))))) (/ (* x y) (* t z))) z)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 3)) (* t (pow z 3))))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (* (- y z) t) #s(hole binary64 (* z (+ (* -1 t) (/ (* t y) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) t))) z)) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* z (+ t (* -1 (/ (* t y) z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ (+ t (/ x (- y z))) t)))
#s(approx (* (- y z) t) #s(hole binary64 (* t (- y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))

Calls

12 calls:

Time	Variable		Point	Expression
29.0ms	z	@	0	((- 1 (/ (/ x (- y t)) (- y z))) (+ (/ x (* (- y z) t)) 1) (/ x (* (- y z) t)) (* (- y z) t) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x (- y t)) z) (/ x (- y t)) (- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (+ (* (/ (- y t) z) y) (neg (- y t))))
3.0ms	x	@	-inf	((- 1 (/ (/ x (- y t)) (- y z))) (+ (/ x (* (- y z) t)) 1) (/ x (* (- y z) t)) (* (- y z) t) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x (- y t)) z) (/ x (- y t)) (- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (+ (* (/ (- y t) z) y) (neg (- y t))))
2.0ms	x	@	inf	((- 1 (/ (/ x (- y t)) (- y z))) (+ (/ x (* (- y z) t)) 1) (/ x (* (- y z) t)) (* (- y z) t) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x (- y t)) z) (/ x (- y t)) (- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (+ (* (/ (- y t) z) y) (neg (- y t))))
2.0ms	z	@	-inf	((- 1 (/ (/ x (- y t)) (- y z))) (+ (/ x (* (- y z) t)) 1) (/ x (* (- y z) t)) (* (- y z) t) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x (- y t)) z) (/ x (- y t)) (- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (+ (* (/ (- y t) z) y) (neg (- y t))))
2.0ms	z	@	inf	((- 1 (/ (/ x (- y t)) (- y z))) (+ (/ x (* (- y z) t)) 1) (/ x (* (- y z) t)) (* (- y z) t) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ x (* (- y t) z)) (* (- y t) z) (- 1 (/ x (* (- y z) (- y t)))) (/ x (* (- y z) (- y t))) (* (- y z) (- y t)) (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (- 1 (/ x (* (- y z) (- y t)))) (+ (/ x (* (- y t) z)) 1) (/ (/ x (- y t)) z) (/ x (- y t)) (- 1 (/ (/ x (- y z)) (- y t))) (/ (/ x (- y z)) (- y t)) (/ x (- y z)) (- y z) (+ (* (/ (- y t) z) y) (neg (- y t))))

simplify210.0ms (3.1%)

Memory

-14.1MiB live, 308.1MiB allocated; 28ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1455	12162
1	4149	11672
0	8291	11367

Stop Event

1×	iter limit
1×	node limit

Counts

384 → 384

Calls

Call 1

Inputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2)))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2)))))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2)))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2))))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2))))))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y z) t) #s(hole binary64 (+ (* -1 (* t z)) (* t y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* t y)) (/ (* x (pow z 2)) (* t (pow y 3))))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (/ x t) (/ (* x z) (* t y))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 3)) (* t (pow y 3)))) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (* (- y z) t) #s(hole binary64 (* t y)))
#s(approx (* (- y z) t) #s(hole binary64 (* y (+ t (* -1 (/ (* t z) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* y z))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow z 2)) t)) (* -1 (/ (* x (pow z 3)) (* t y)))) y)) (/ (* x z) t)) y))) y))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* y (+ (* -1 t) (/ (* t z) y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* t (pow z 3)))))) (/ (* x y) (* t (pow z 2))))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 2)) (* t (pow z 2))))) (/ (* x y) (* t z))) z)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 3)) (* t (pow z 3))))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (* (- y z) t) #s(hole binary64 (* z (+ (* -1 t) (/ (* t y) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) t))) z)) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* z (+ t (* -1 (/ (* t y) z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ (+ t (/ x (- y z))) t)))
#s(approx (* (- y z) t) #s(hole binary64 (* t (- y z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))

Outputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (/ x (* (- y z) t)) (/.f64 (/.f64 x t) (-.f64 y z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 1))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 x (-.f64 y t)) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 x (-.f64 y t)) z))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x (- y t))))
#s(approx (/ x (- y t)) (/.f64 x (-.f64 y t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 1))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 y z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* (- y t) (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x (- y z))))
#s(approx (/ x (- y z)) (/.f64 x (-.f64 y z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) (-.f64 y t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ x (* t (- y z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (/.f64 (/.f64 x t) (-.f64 y z)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* t (- y z)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (-.f64 y z) t)) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ x (* z (- y t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ 1 (* z (- y t)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 z (-.f64 y t))) (/.f64 #s(literal 1 binary64) x)) x))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (/ x (* (- y t) (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) (-.f64 y t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* x (- (/ 1 x) (/ 1 (* (- y t) (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (-.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z))) x))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (neg.f64 x) (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (neg.f64 x) (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (* -1 (* x (- (/ 1 (* (- y t) (- y z))) (/ 1 x))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (*.f64 (neg.f64 x) (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 y t)) (-.f64 y z)) (/.f64 #s(literal 1 binary64) x))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 z t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 t t)) (/.f64 x (.f64 z z)) #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (.f64 (.f64 z z) (.f64 t t)))) y #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 z t)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 x (*.f64 z t))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (fma.f64 (/.f64 x (*.f64 z t)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (neg.f64 (fma.f64 x (/.f64 y (.f64 (.f64 z z) t)) (/.f64 x (*.f64 z t)))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2)))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 z #s(literal 3 binary64)) t))) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (neg.f64 x) (*.f64 z t))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2)))))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 z #s(literal 4 binary64)) t))) (/.f64 x (.f64 (pow.f64 z #s(literal 3 binary64)) t))) y) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (neg.f64 x) (*.f64 z t))) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y z) t)) (/.f64 (neg.f64 x) (*.f64 z t)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* t (pow z 2)))))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (fma.f64 x (/.f64 y (.f64 (.f64 z z) t)) (/.f64 x (*.f64 z t)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* t (pow z 3)))) (/ x (* t (pow z 2))))))))
#s(approx (/ x (* (- y z) t)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 z #s(literal 3 binary64)) t))) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* t (pow z 4)))) (/ x (* t (pow z 3))))) (/ x (* t (pow z 2))))))))
#s(approx (/ x (* (- y z) t)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 z #s(literal 4 binary64)) t))) (/.f64 x (.f64 (pow.f64 z #s(literal 3 binary64)) t))) y) (/.f64 x (.f64 (.f64 z z) t))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y z) t) (*.f64 (neg.f64 z) t))
#s(approx (* (- y z) t) #s(hole binary64 (+ (* -1 (* t z)) (* t y))))
#s(approx (* (- y z) t) (fma.f64 (neg.f64 z) t (*.f64 t y)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 z t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 t t)) (/.f64 x (.f64 z z)) #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (.f64 (.f64 z z) (.f64 t t)))) y #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 z t)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 x (*.f64 z t))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ x (* t z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 x (*.f64 z t)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z)))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 3 binary64)) z))) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z))))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 4 binary64)) z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 x) (*.f64 z t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 3 binary64)) z))) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 4 binary64)) z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t z))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 z) t))
#s(approx (* (- y t) z) #s(hole binary64 (+ (* -1 (* t z)) (* y z))))
#s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 z t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 z z)) (/.f64 x (.f64 z t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 z t)) (.f64 (.f64 z z) (.f64 t t))))) y (/.f64 x (.f64 z t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 z t)) (.f64 z z)))) y (/.f64 x (.f64 z t))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t z)))
#s(approx (* (- y z) (- y t)) (*.f64 z t))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ (* -1 t) (* -1 z))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 (+.f64 z t)) y (*.f64 z t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* t z) (* y (+ y (+ (* -1 t) (* -1 z)))))))
#s(approx (* (- y z) (- y t)) (fma.f64 (fma.f64 #s(literal -1 binary64) (+.f64 z t) y) y (*.f64 z t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 z t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (* z (- (* -1 (/ t z)) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (.f64 (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) z) y (.f64 z t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t z) (* y (+ y (* z (- (* -1 (/ t z)) 1)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (fma.f64 (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) z y) y (*.f64 z t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ x (* t z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 x) (*.f64 z t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x y) (* (pow t 2) z))))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (+.f64 (/.f64 x t) (*.f64 (/.f64 y t) (/.f64 x t))) z)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* -1 (/ (* x y) (* (pow t 3) z))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 3 binary64)) z))) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* -1 (/ x (* t z))) (* y (- (* y (- (* -1 (/ (* x y) (* (pow t 4) z))) (/ x (* (pow t 3) z)))) (/ x (* (pow t 2) z)))))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (pow.f64 t #s(literal 4 binary64)) z))) (/.f64 x (.f64 (pow.f64 t #s(literal 3 binary64)) z))) y) (/.f64 x (.f64 (.f64 t t) z))) y (/.f64 (neg.f64 x) (*.f64 z t))))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ x t))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 x) t))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* -1 (/ (* x y) (pow t 2))))))
#s(approx (/ x (- y t)) (neg.f64 (fma.f64 x (/.f64 y (*.f64 t t)) (/.f64 x t))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* -1 (/ (* x y) (pow t 3))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 t #s(literal 3 binary64)))) (/.f64 x (.f64 t t))) y (/.f64 (neg.f64 x) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* -1 (/ x t)) (* y (- (* y (- (* -1 (/ (* x y) (pow t 4))) (/ x (pow t 3)))) (/ x (pow t 2)))))))
#s(approx (/ x (- y t)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 t #s(literal 4 binary64)))) (/.f64 x (pow.f64 t #s(literal 3 binary64)))) y) (/.f64 x (*.f64 t t))) y (/.f64 (neg.f64 x) t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 z t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 t t)) (/.f64 x (.f64 z z)) #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) y (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (.f64 (.f64 z z) (.f64 t t)))) y #s(literal 1 binary64)) (/.f64 x (.f64 z t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* y (+ (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (+ (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z))))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2)))))) (/ x (* t z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (/.f64 (neg.f64 (+.f64 z t)) (.f64 t t)) (/.f64 x (.f64 z z)) (.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (fma.f64 (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64))))) y (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y)) y #s(literal 1 binary64)) (/.f64 x (*.f64 z t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* t z))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 z t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* -1 (/ (* x (* y (+ (* -1 t) (* -1 z)))) (* (pow t 2) (pow z 2)))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) y) (.f64 z z)) (/.f64 x (.f64 z t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* -1 (* y (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (neg.f64 y) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 (neg.f64 x) (/.f64 (neg.f64 (+.f64 z t)) (.f64 (.f64 z z) (.f64 t t))))) y (/.f64 x (.f64 z t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* y (- (* y (- (* -1 (* y (+ (* -1 (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 3) (pow z 3)))) (* -1 (/ (* (+ (* -1 t) (* -1 z)) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2))))) (* t z)))))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (* (pow t 3) (pow z 3)))) (/ x (* (pow t 2) (pow z 2)))))) (/ (* x (+ (* -1 t) (* -1 z))) (* (pow t 2) (pow z 2))))) (/ x (* t z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (neg.f64 y) (neg.f64 (fma.f64 (neg.f64 (+.f64 z t)) (/.f64 (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z))) (.f64 z t)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 (.f64 z t) #s(literal 3 binary64)))))) (fma.f64 (neg.f64 x) (/.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (pow.f64 (.f64 z t) #s(literal 3 binary64))) (/.f64 (/.f64 x (.f64 t t)) (.f64 z z)))) y (.f64 (neg.f64 (/.f64 x (.f64 t t))) (/.f64 (neg.f64 (+.f64 z t)) (.f64 z z)))) y (/.f64 x (.f64 z t))))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ x z))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 x) z))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* -1 (/ (* x y) (pow z 2))))))
#s(approx (/ x (- y z)) (neg.f64 (fma.f64 x (/.f64 y (*.f64 z z)) (/.f64 x z))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* -1 (/ (* x y) (pow z 3))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) (fma.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 z #s(literal 3 binary64)))) (/.f64 x (.f64 z z))) y (/.f64 (neg.f64 x) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* -1 (/ x z)) (* y (- (* y (- (* -1 (/ (* x y) (pow z 4))) (/ x (pow z 3)))) (/ x (pow z 2)))))))
#s(approx (/ x (- y z)) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (pow.f64 z #s(literal 4 binary64)))) (/.f64 x (pow.f64 z #s(literal 3 binary64)))) y) (/.f64 x (*.f64 z z))) y (/.f64 (neg.f64 x) z)))
#s(approx (- y z) #s(hole binary64 (* -1 z)))
#s(approx (- y z) (neg.f64 z))
#s(approx (- y z) #s(hole binary64 (- y z)))
#s(approx (- y z) (-.f64 y z))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (* -1 (/ t z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (-.f64 (/.f64 (neg.f64 t) z) #s(literal 1 binary64)) y t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (+ t (* y (- (+ (* -1 (/ t z)) (/ y z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (-.f64 (/.f64 (fma.f64 #s(literal -1 binary64) t y) z) #s(literal 1 binary64)) y t))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 z t)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (/ x (* t y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (/.f64 (/.f64 x t) y) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (fma.f64 (/.f64 z t) (/.f64 x (*.f64 y y)) (/.f64 (/.f64 x t) y)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* t y)) (/ (* x (pow z 2)) (* t (pow y 3))))) (* -1 (/ (* x z) (* t (pow y 2)))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (-.f64 (+.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x (pow.f64 y #s(literal 3 binary64))) (/.f64 (/.f64 x t) y)) #s(literal 1 binary64)) (.f64 (neg.f64 x) (/.f64 z (.f64 (.f64 y y) t)))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ x (* t y))))
#s(approx (/ x (* (- y z) t)) (/.f64 (/.f64 x t) y))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (/ x t) (/ (* x z) (* t y))) y)))
#s(approx (/ x (* (- y z) t)) (/.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t)) y))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 2)) (* t (pow y 2)))) (* -1 (/ (* x z) (* t y)))) y)))
#s(approx (/ x (* (- y z) t)) (/.f64 (-.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x (.f64 y y)) (/.f64 x t)) (.f64 (neg.f64 x) (/.f64 z (.f64 t y)))) y))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (/ x t) (/ (* x (pow z 3)) (* t (pow y 3)))) (+ (* -1 (/ (* x z) (* t y))) (* -1 (/ (* x (pow z 2)) (* t (pow y 2)))))) y)))
#s(approx (/ x (* (- y z) t)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 z y) #s(literal 3 binary64)) (/.f64 x t) (/.f64 x t)) (neg.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x (.f64 y y)) (*.f64 (/.f64 z t) (/.f64 x y))))) y))
#s(approx (* (- y z) t) #s(hole binary64 (* t y)))
#s(approx (* (- y z) t) (*.f64 t y))
#s(approx (* (- y z) t) #s(hole binary64 (* y (+ t (* -1 (/ (* t z) y))))))
#s(approx (* (- y z) t) (*.f64 (fma.f64 (neg.f64 t) (/.f64 z y) t) y))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 z t)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (/ x (* y z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 x (*.f64 z y)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) z) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (/ x (* y z)) (/ (* (pow t 2) x) (* (pow y 3) z)))) (* -1 (/ (* t x) (* (pow y 2) z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (+.f64 (/.f64 (+.f64 (/.f64 (.f64 (.f64 t t) x) (pow.f64 y #s(literal 3 binary64))) (/.f64 x y)) z) #s(literal 1 binary64)) (.f64 (/.f64 t (.f64 y y)) (/.f64 (neg.f64 x) z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 z y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t t) (/.f64 x (.f64 y y)) x) z) (*.f64 (/.f64 (neg.f64 t) y) (/.f64 x z))) y))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 t y) #s(literal 3 binary64)) (/.f64 x z) (/.f64 x z)) (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) (.f64 (/.f64 (.f64 t t) y) (/.f64 x y))) z))) y))
#s(approx (* (- y t) z) #s(hole binary64 (* y z)))
#s(approx (* (- y t) z) (*.f64 z y))
#s(approx (* (- y t) z) #s(hole binary64 (* y (+ z (* -1 (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 t) (/.f64 z y) z) y))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 x (.f64 #s(literal 1 binary64) (/.f64 (+.f64 z t) y)) x) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y) x) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y)) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (neg.f64 (+.f64 z t)) (.f64 (.f64 (.f64 (neg.f64 (+.f64 z t)) z) x) t))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (pow y 2)))
#s(approx (* (- y z) (- y t)) (*.f64 y y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (* -1 (/ z y)))))))
#s(approx (* (- y z) (- y t)) (.f64 (neg.f64 (+.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ t y)) (+ (* -1 (/ z y)) (/ (* t z) (pow y 2))))))))
#s(approx (* (- y z) (- y t)) (.f64 (+.f64 (fma.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64) (.f64 (/.f64 z y) (/.f64 t y))) #s(literal 1 binary64)) (*.f64 y y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (pow y 2)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 y y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (* z (+ 1 (/ t z))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (+ (* -1 (/ (* z (+ 1 (/ t z))) y)) (/ (* t z) (pow y 2)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (+.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64))) (.f64 (/.f64 z y) (/.f64 t y))) (*.f64 y y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ x (* y z))))
#s(approx (/ x (* (- y t) z)) (/.f64 x (*.f64 z y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (/ x z) (/ (* t x) (* y z))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z) y))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 2) x) (* (pow y 2) z))) (* -1 (/ (* t x) (* y z)))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (/.f64 (fma.f64 (.f64 t t) (/.f64 x (.f64 y y)) x) z) (*.f64 (/.f64 (neg.f64 t) y) (/.f64 x z))) y))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (/ x z) (/ (* (pow t 3) x) (* (pow y 3) z))) (+ (* -1 (/ (* t x) (* y z))) (* -1 (/ (* (pow t 2) x) (* (pow y 2) z))))) y)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (fma.f64 (pow.f64 (/.f64 t y) #s(literal 3 binary64)) (/.f64 x z) (/.f64 x z)) (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) (.f64 (/.f64 (.f64 t t) y) (/.f64 x y))) z))) y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y t)) (/.f64 x y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ x (/ (* t x) y)) y)))
#s(approx (/ x (- y t)) (/.f64 (fma.f64 t (/.f64 x y) x) y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 2) x) (pow y 2))) (* -1 (/ (* t x) y))) y)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (fma.f64 (.f64 t t) (/.f64 x (.f64 y y)) x) (*.f64 (neg.f64 t) (/.f64 x y))) y))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ x (/ (* (pow t 3) x) (pow y 3))) (+ (* -1 (/ (* t x) y)) (* -1 (/ (* (pow t 2) x) (pow y 2))))) y)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (fma.f64 (pow.f64 t #s(literal 3 binary64)) (/.f64 x (pow.f64 y #s(literal 3 binary64))) x) (neg.f64 (fma.f64 (/.f64 (.f64 t t) y) (/.f64 x y) (.f64 t (/.f64 x y))))) y))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ x (pow y 2))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 x (*.f64 y y)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 x (/.f64 (neg.f64 (+.f64 z t)) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 4))) (+ (/ (* t (* x z)) (pow y 4)) (/ (* x (+ (* -1 t) (* -1 z))) (pow y 3))))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (pow.f64 y #s(literal 4 binary64))) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) (pow.f64 y #s(literal 3 binary64)))) #s(literal 1 binary64)) (/.f64 x (.f64 y y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (* x (+ (* -1 t) (* -1 z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 x (.f64 #s(literal 1 binary64) (/.f64 (+.f64 z t) y)) x) (.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z))) (pow y 2)))) (/ (* x (+ (* -1 t) (* -1 z))) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal -1 binary64) y) (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y) x) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y)) (.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ x (* -1 (/ (+ (* -1 (* t (* x (* z (+ (* -1 t) (* -1 z)))))) (* -1 (* (+ (* -1 t) (* -1 z)) (+ (* -1 (* x (pow (+ (* -1 t) (* -1 z)) 2))) (* t (* x z)))))) (pow y 3)))) (+ (* -1 (/ (* x (pow (+ (* -1 t) (* -1 z)) 2)) (pow y 2))) (+ (/ (* t (* x z)) (pow y 2)) (/ (* x (+ (* -1 t) (* -1 z))) y)))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (fma.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (neg.f64 (+.f64 z t)) (.f64 (.f64 (.f64 (neg.f64 (+.f64 z t)) z) x) t))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) x) (+.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) (.f64 y y)) (/.f64 (.f64 (neg.f64 (+.f64 z t)) x) y))) (.f64 y y)))
#s(approx (/ x (- y z)) #s(hole binary64 (/ x y)))
#s(approx (/ x (- y z)) (/.f64 x y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ x (/ (* x z) y)) y)))
#s(approx (/ x (- y z)) (/.f64 (fma.f64 x (/.f64 z y) x) y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 2)) (pow y 2))) (* -1 (/ (* x z) y))) y)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (fma.f64 (/.f64 (.f64 z z) y) (/.f64 x y) x) (.f64 x (/.f64 (neg.f64 z) y))) y))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ x (/ (* x (pow z 3)) (pow y 3))) (+ (* -1 (/ (* x z) y)) (* -1 (/ (* x (pow z 2)) (pow y 2))))) y)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (fma.f64 x (pow.f64 (/.f64 z y) #s(literal 3 binary64)) x) (neg.f64 (fma.f64 (/.f64 (.f64 z z) y) (/.f64 x y) (.f64 x (/.f64 z y))))) y))
#s(approx (- y z) #s(hole binary64 y))
#s(approx (- y z) y)
#s(approx (- y z) #s(hole binary64 (* y (+ 1 (* -1 (/ z y))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 z y) #s(literal -1 binary64) #s(literal 1 binary64)) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (pow y 2) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (/.f64 (*.f64 y y) z))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (/ t z)) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) y) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) (.f64 y y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (- (+ (/ 1 z) (/ t (pow y 2))) (+ (/ 1 y) (/ t (* y z)))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (-.f64 (-.f64 (+.f64 (/.f64 t (.f64 y y)) (/.f64 #s(literal 1 binary64) z)) (/.f64 #s(literal 1 binary64) y)) (/.f64 (/.f64 t y) z)) (*.f64 y y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 z t) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 z t) x (neg.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (fma.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t))) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (fma.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x y) (/.f64 (.f64 z x) t)) y) (/.f64 x t))) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x z) (* t y)))) y))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 z t) (/.f64 x y) (/.f64 x t))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (/ (* x z) t) (/ (* x (pow z 2)) (* t y))) y))) y))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 z z) t) (/.f64 x y) (/.f64 (.f64 z x) t)) y) (/.f64 x t))) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x t)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* x (pow z 2)) t)) (* -1 (/ (* x (pow z 3)) (* t y)))) y)) (/ (* x z) t)) y))) y))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 x (/.f64 z t) (neg.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 (pow.f64 z #s(literal 3 binary64)) t) (/.f64 x y) (/.f64 (.f64 (.f64 z z) x) t))) y))) y) (/.f64 x t))) y)))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* y (+ (* -1 t) (/ (* t z) y))))))
#s(approx (* (- y z) t) (*.f64 (neg.f64 y) (fma.f64 t (/.f64 z y) (neg.f64 t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 z t) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 z t) x (neg.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z)) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) y) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z)) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) y)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t (/.f64 x z) (neg.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y)) z)) y))) y) (/.f64 x z))) y)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* y (+ (* -1 z) (/ (* t z) y))))))
#s(approx (* (- y t) z) (*.f64 (neg.f64 y) (fma.f64 t (/.f64 z y) (neg.f64 z))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 x (/.f64 (+.f64 z t) y) x) (*.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 z t) z) x) t (.f64 (+.f64 z t) (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)))) y) (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) x)) (.f64 (.f64 z x) t)) y)) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t z) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (neg.f64 (+.f64 (/.f64 (+.f64 z t) y) #s(literal -1 binary64))) (.f64 y y)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ t (+ z (* -1 (/ (* t z) y)))) y))))))
#s(approx (* (- y z) (- y t)) (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (neg.f64 t) (/.f64 z y) z) t) y) #s(literal -1 binary64) #s(literal 1 binary64)) (.f64 y y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* (pow y 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* t z) y)) (* z (+ 1 (/ t z)))) y))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 (/.f64 t z) #s(literal 1 binary64)) z (/.f64 (.f64 (neg.f64 z) t) y)) y) #s(literal -1 binary64) #s(literal 1 binary64)) (*.f64 y y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (* t x) (* y z)))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 t (/.f64 x y) x) z)) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (/ (* t x) z) (/ (* (pow t 2) x) (* y z))) y))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) z) y) (/.f64 x z))) y)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ x z)) (* -1 (/ (+ (* -1 (/ (+ (* -1 (/ (* (pow t 2) x) z)) (* -1 (/ (* (pow t 3) x) (* y z)))) y)) (/ (* t x) z)) y))) y))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t (/.f64 x z) (neg.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y)) z)) y))) y) (/.f64 x z))) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* t x) y))) y))))
#s(approx (/ x (- y t)) (neg.f64 (/.f64 (neg.f64 (fma.f64 t (/.f64 x y) x)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* t x) (/ (* (pow t 2) x) y)) y))) y))))
#s(approx (/ x (- y t)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t x (/.f64 (.f64 (.f64 t t) x) y)) y) x)) y)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* (pow t 2) x)) (* -1 (/ (* (pow t 3) x) y))) y)) (* t x)) y))) y))))
#s(approx (/ x (- y t)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 t x (neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 t t) x (/.f64 (.f64 (pow.f64 t #s(literal 3 binary64)) x) y))) y))) y) x)) y)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x (+ t z)) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 x) (/.f64 (+.f64 z t) (pow.f64 y #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z))) y)) (* x (+ t z))) (pow y 3)))) (/ x (pow y 2)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 z t) x (neg.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y))) (pow.f64 y #s(literal 3 binary64))) #s(literal -1 binary64) #s(literal 1 binary64)) (/.f64 x (*.f64 y y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (/ (* x (+ t z)) y)) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 x (/.f64 (+.f64 z t) y) x) (*.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (+ (* -1 (/ (* x (pow (+ t z) 2)) y)) (/ (* t (* x z)) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)) y) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ x (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* t (* x (* z (+ t z)))) y)) (* -1 (/ (* (+ t z) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y))) (+ (* -1 (* x (pow (+ t z) 2))) (* t (* x z)))) y)) (* x (+ t z))) y))) (pow y 2))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (.f64 (.f64 (+.f64 z t) z) x) t (.f64 (+.f64 z t) (fma.f64 (neg.f64 x) (pow.f64 (+.f64 z t) #s(literal 2 binary64)) (.f64 (.f64 z x) t)))) y) (.f64 (pow.f64 (+.f64 z t) #s(literal 2 binary64)) x)) (.f64 (.f64 z x) t)) y)) (.f64 (+.f64 z t) x)) y) #s(literal -1 binary64) x) (.f64 y y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (* x z) y))) y))))
#s(approx (/ x (- y z)) (neg.f64 (/.f64 (neg.f64 (fma.f64 x (/.f64 z y) x)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* x z) (/ (* x (pow z 2)) y)) y))) y))))
#s(approx (/ x (- y z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 z x (/.f64 (.f64 (.f64 z z) x) y)) y) x)) y)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ (* -1 x) (* -1 (/ (+ (* -1 (/ (+ (* -1 (* x (pow z 2))) (* -1 (/ (* x (pow z 3)) y))) y)) (* x z)) y))) y))))
#s(approx (/ x (- y z)) (neg.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 z x (neg.f64 (/.f64 (neg.f64 (fma.f64 x (/.f64 (pow.f64 z #s(literal 3 binary64)) y) (.f64 (.f64 z z) x))) y))) y) x)) y)))
#s(approx (- y z) #s(hole binary64 (* -1 (* y (- (/ z y) 1)))))
#s(approx (- y z) (*.f64 (neg.f64 y) (-.f64 (/.f64 z y) #s(literal 1 binary64))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* (pow y 2) (+ (* -1 (/ (+ 1 (+ (* -1 (/ t y)) (/ t z))) y)) (/ 1 z)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (/.f64 t y) #s(literal -1 binary64) (/.f64 t z)) #s(literal 1 binary64)) y) #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) z)) (.f64 y y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (.f64 y y)) (/.f64 x (-.f64 y t)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y t)))) z #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (fma.f64 (fma.f64 (/.f64 z t) (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (*.f64 y y) t)))) z (/.f64 (/.f64 x t) y)) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (+.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 z t) (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) t)))) z (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (*.f64 y y) t)))) z (/.f64 (/.f64 x t) y)) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (/ x (* t y)) (/ (* x z) (* t (pow y 2))))))
#s(approx (/ x (* (- y z) t)) (fma.f64 (/.f64 z t) (/.f64 x (*.f64 y y)) (/.f64 (/.f64 x t) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* t (pow y 3))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (/ x (* (- y z) t)) (fma.f64 (fma.f64 (/.f64 z t) (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (*.f64 y y) t)))) z (/.f64 (/.f64 x t) y)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* t (pow y 4))) (* -1 (/ x (* t (pow y 3)))))) (* -1 (/ x (* t (pow y 2)))))) (/ x (* t y)))))
#s(approx (/ x (* (- y z) t)) (fma.f64 (fma.f64 (fma.f64 (/.f64 z t) (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (pow.f64 y #s(literal 3 binary64)) t)))) z (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (*.f64 y y) t)))) z (/.f64 (/.f64 x t) y)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (.f64 y y)) (/.f64 x (-.f64 y t)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y t)))) z #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (/ (+ z (/ x (- y t))) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (+.f64 z (/.f64 x (-.f64 y t))) z))
#s(approx (* (- y t) z) #s(hole binary64 (* z (- y t))))
#s(approx (* (- y t) z) (*.f64 z (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 x y) (/.f64 z y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (-.f64 (.f64 (/.f64 z (-.f64 y t)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y t)))) z (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 z (-.f64 y t))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y t))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y t) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* z (- y t))) (* y (- y t)))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 z) (-.f64 y t) (*.f64 (-.f64 y t) y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* y (- y t))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 y t) y))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* y (- y t)) (* z (- t y)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (-.f64 t y) z (*.f64 (-.f64 y t) y)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* x z) (* (pow y 2) (- y t))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 z (.f64 y y)) (/.f64 x (-.f64 y t)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* -1 (/ (* x z) (* (pow y 3) (- y t))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))))) (-.f64 y t))) z #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* z (+ (* -1 (/ x (* (pow y 2) (- y t)))) (* z (+ (* -1 (/ x (* (pow y 3) (- y t)))) (* -1 (/ (* x z) (* (pow y 4) (- y t))))))))) (/ x (* y (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (-.f64 y t))) z (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y t)))) z #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 (-.f64 y t) y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y t))) (/ (* x z) (* (pow y 2) (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 (/.f64 x y) (/.f64 z y) (/.f64 x y)) (-.f64 y t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (/ (* x z) (* (pow y 3) (- y t))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (-.f64 (.f64 (/.f64 z (-.f64 y t)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y t)))) z (/.f64 x (.f64 (-.f64 y t) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (* (pow y 4) (- y t))) (* -1 (/ x (* (pow y 3) (- y t)))))) (* -1 (/ x (* (pow y 2) (- y t)))))) (/ x (* y (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 z (-.f64 y t))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y t)))) z (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y t)))) z (/.f64 x (*.f64 (-.f64 y t) y))))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (/ x y) (/ (* x z) (pow y 2)))))
#s(approx (/ x (- y z)) (fma.f64 (/.f64 x y) (/.f64 z y) (/.f64 x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (/ (* x z) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) (fma.f64 (fma.f64 x (/.f64 z (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 y y)))) z (/.f64 x y)))
#s(approx (/ x (- y z)) #s(hole binary64 (+ (* z (- (* z (- (/ (* x z) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y z)) (fma.f64 (fma.f64 (fma.f64 x (/.f64 z (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (pow.f64 y #s(literal 3 binary64))))) z (.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y)))) z (/.f64 x y)))
#s(approx (- y z) #s(hole binary64 (+ y (* -1 z))))
#s(approx (- y z) (fma.f64 #s(literal -1 binary64) z y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (* y (- y t)) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (/.f64 (-.f64 y t) z) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (/ (+ (* y (- y t)) (* z (- t y))) z)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (/.f64 (fma.f64 (-.f64 t y) z (*.f64 (-.f64 y t) y)) z))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 z z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 z (-.f64 y t)))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 z (-.f64 y t)))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* t (pow z 3)))))) (/ (* x y) (* t (pow z 2))))))
#s(approx (+ (/ x (* (- y z) t)) 1) (-.f64 (+.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (pow.f64 z #s(literal 3 binary64))) (/.f64 x (.f64 z t)))) #s(literal 1 binary64)) (.f64 (/.f64 y (.f64 z z)) (/.f64 x t))))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (+ (* -1 (/ x t)) (* -1 (/ (* x y) (* t z)))) z)))
#s(approx (/ x (* (- y z) t)) (/.f64 (neg.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t))) z))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 2)) (* t (pow z 2))))) (/ (* x y) (* t z))) z)))
#s(approx (/ x (* (- y z) t)) (/.f64 (-.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (/.f64 x t))) (*.f64 (/.f64 y t) (/.f64 x z))) z))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (/ (- (+ (* -1 (/ x t)) (* -1 (/ (* x (pow y 3)) (* t (pow z 3))))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* t (pow z 2))))) z)))
#s(approx (/ x (* (- y z) t)) (/.f64 (-.f64 (neg.f64 (fma.f64 (pow.f64 (/.f64 y z) #s(literal 3 binary64)) (/.f64 x t) (/.f64 x t))) (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x (.f64 z z)) (*.f64 (/.f64 y t) (/.f64 x z)))) z))
#s(approx (* (- y z) t) #s(hole binary64 (* z (+ (* -1 t) (/ (* t y) z)))))
#s(approx (* (- y z) t) (*.f64 (fma.f64 t (/.f64 y z) (neg.f64 t)) z))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 z z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 z (-.f64 y t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 z (-.f64 y t)))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 x) (*.f64 z (-.f64 y t))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t))) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (*.f64 x (/.f64 y z))) (-.f64 y t))) z))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- y t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 z) (-.f64 y t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* z (+ (* -1 (- y t)) (/ (* y (- y t)) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- t y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 t y) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (+ t (/ (* y (- y t)) z)) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (-.f64 (fma.f64 (/.f64 (-.f64 y t) z) y t) y) z))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* z (- y t))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow z 2) (- y t)))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 z z)) (/.f64 x (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 z (-.f64 y t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow z 2) (- y t))) (/ (* x (pow y 2)) (* (pow z 3) (- y t))))) (* -1 (/ x (* z (- y t)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y z) (/.f64 x z) (/.f64 (.f64 (.f64 y y) x) (pow.f64 z #s(literal 3 binary64)))) (-.f64 y t)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 z (-.f64 y t)))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* z (- y t))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 x) (*.f64 z (-.f64 y t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y t))) (* -1 (/ (* x y) (* z (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t))) z))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) (/ (* x y) (* z (- y t)))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) z) (/.f64 x z))) (-.f64 y t))) (*.f64 (/.f64 y (-.f64 y t)) (/.f64 x z))) z))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y t))) (* -1 (/ (* x (pow y 3)) (* (pow z 3) (- y t))))) (+ (/ (* x y) (* z (- y t))) (/ (* x (pow y 2)) (* (pow z 2) (- y t))))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)))) (-.f64 y t))) (/.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (*.f64 x (/.f64 y z))) (-.f64 y t))) z))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) z))) z)))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 (fma.f64 x (/.f64 y z) x)) z))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow z 2)))) (/ (* x y) z)) z)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) x)) (.f64 x (/.f64 y z))) z))
#s(approx (/ x (- y z)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow z 3)))) (+ (/ (* x y) z) (/ (* x (pow y 2)) (pow z 2)))) z)))
#s(approx (/ x (- y z)) (/.f64 (-.f64 (neg.f64 (fma.f64 x (pow.f64 (/.f64 y z) #s(literal 3 binary64)) x)) (fma.f64 (/.f64 (.f64 y y) z) (/.f64 x z) (.f64 x (/.f64 y z)))) z))
#s(approx (- y z) #s(hole binary64 (* z (- (/ y z) 1))))
#s(approx (- y z) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- t y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 t y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ t (/ (* y (- y t)) z)) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 (fma.f64 (/.f64 (-.f64 y t) z) y t) y))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 z (-.f64 y t)))) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) z)) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (fma.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t)) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z)))))
#s(approx (+ (/ x (* (- y z) t)) 1) (fma.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t)) (/.f64 (*.f64 y x) t)) z) #s(literal -1 binary64) (/.f64 x t)) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (/ x t) (/ (* x y) (* t z))) z))))
#s(approx (/ x (* (- y z) t)) (/.f64 (neg.f64 (fma.f64 (/.f64 y t) (/.f64 x z) (/.f64 x t))) z))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t)) (/.f64 (*.f64 y x) t)) z) #s(literal -1 binary64) (/.f64 x t)) z)))
#s(approx (/ x (* (- y z) t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) t))) z)) (/ (* x y) t)) z)) (/ x t)) z))))
#s(approx (/ x (* (- y z) t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 y y) x) t))) z)) (/.f64 (.f64 y x) t)) z) #s(literal -1 binary64) (/.f64 x t)) z)))
#s(approx (* (- y z) t) #s(hole binary64 (* -1 (* z (+ t (* -1 (/ (* t y) z)))))))
#s(approx (* (- y z) t) (*.f64 (fma.f64 (neg.f64 t) (/.f64 y z) t) (neg.f64 z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 z (-.f64 y t)))) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) z)) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t))) z))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 y y) z) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (.f64 (neg.f64 x) (/.f64 (.f64 y y) (-.f64 y t)))) z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* z (- (+ y (* -1 (/ (* y (- y t)) z))) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 (fma.f64 (neg.f64 y) (/.f64 (-.f64 y t) z) y) t) (neg.f64 z)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* z (+ (* -1 (- t y)) (* -1 (/ (* y (- y t)) z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (*.f64 (neg.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (-.f64 t y))) (neg.f64 z)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* z (- y t)))) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 z (-.f64 y t)))) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y t)) (/ (* x (pow y 2)) (* z (- y t)))) z)) (/ x (- y t))) z)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) z) (.f64 y x)) (-.f64 y t)) z)) (/.f64 x (-.f64 y t))) z) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y t)) (/ (* x y) (* z (- y t)))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y z) x) (-.f64 y t))) z))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* z (- y t)))) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y t)) (/.f64 (.f64 y y) z) (.f64 (neg.f64 x) (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* z (- y t))) (* -1 (/ (* x (pow y 2)) (- y t)))) z)) (/ (* x y) (- y t))) z)) (/ x (- y t))) z))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (/.f64 x (-.f64 y t))) (.f64 (neg.f64 x) (/.f64 (.f64 y y) (-.f64 y t)))) z)) (.f64 x (/.f64 y (-.f64 y t)))) z) #s(literal -1 binary64) (/.f64 x (-.f64 y t))) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) z)) z))))
#s(approx (/ x (- y z)) (/.f64 (neg.f64 (fma.f64 x (/.f64 y z) x)) z))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (neg.f64 x) (/.f64 (.f64 y y) z) (.f64 (neg.f64 y) x)) z) #s(literal -1 binary64) x) z)))
#s(approx (/ x (- y z)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) z) (* -1 (* x (pow y 2)))) z)) (* x y)) z))) z))))
#s(approx (/ x (- y z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 (pow.f64 y #s(literal 3 binary64)) z) (.f64 (.f64 y y) x)) z)) (*.f64 y x)) z) #s(literal -1 binary64) x) z)))
#s(approx (- y z) #s(hole binary64 (* -1 (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (- y z) (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) (neg.f64 z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y z)))) t #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (+ (/ x (* (- y z) t)) 1) #s(hole binary64 (/ (+ t (/ x (- y z))) t)))
#s(approx (+ (/ x (* (- y z) t)) 1) (/.f64 (+.f64 (/.f64 x (-.f64 y z)) t) t))
#s(approx (* (- y z) t) #s(hole binary64 (* t (- y z))))
#s(approx (* (- y z) t) (*.f64 (-.f64 y z) t))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y z)))) t #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z))))))
#s(approx (+ (/ x (* (- y t) z)) 1) (+.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 t z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (.f64 z y))) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) z))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 t z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (.f64 z y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y z)))) t (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* y (- y z))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 y z) y))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (+ (* -1 (* t (- y z))) (* y (- y z)))))
#s(approx (* (- y z) (- y t)) (fma.f64 (neg.f64 t) (-.f64 y z) (*.f64 (-.f64 y z) y)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* z (- (/ (pow y 2) z) y))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (-.f64 (/.f64 (.f64 y y) z) y) z))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (+ (* t (* z (+ 1 (* -1 (/ y z))))) (* z (- (/ (pow y 2) z) y)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (fma.f64 (-.f64 (/.f64 (.f64 y y) z) y) z (.f64 (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (/ x (* y z)) (/ (* t x) (* (pow y 2) z)))))
#s(approx (/ x (* (- y t) z)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) z))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) z)) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (/.f64 t (pow.f64 y #s(literal 3 binary64))) (/.f64 x z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (*.f64 z y))))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) z)) (* -1 (/ x (* (pow y 3) z))))) (* -1 (/ x (* (pow y 2) z))))) (/ x (* y z)))))
#s(approx (/ x (* (- y t) z)) (fma.f64 (fma.f64 (fma.f64 (/.f64 x (pow.f64 y #s(literal 4 binary64))) (/.f64 t z) (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) z))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) z))) t (/.f64 x (.f64 z y))))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (/ x y) (/ (* t x) (pow y 2)))))
#s(approx (/ x (- y t)) (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (pow y 3)) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) (fma.f64 (fma.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 y y)))) t (/.f64 x y)))
#s(approx (/ x (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (pow y 4)) (* -1 (/ x (pow y 3))))) (* -1 (/ x (pow y 2))))) (/ x y))))
#s(approx (/ x (- y t)) (fma.f64 (fma.f64 (fma.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))) (.f64 #s(literal 1 binary64) (/.f64 x (pow.f64 y #s(literal 3 binary64))))) t (.f64 #s(literal 1 binary64) (/.f64 x (*.f64 y y)))) t (/.f64 x y)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- 1 (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* -1 (/ (* t x) (* (pow y 2) (- y z))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (neg.f64 (fma.f64 (/.f64 t (-.f64 y z)) (/.f64 x (.f64 y y)) #s(literal -1 binary64))) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* -1 (/ (* t x) (* (pow y 3) (- y z))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (.f64 y y)) (.f64 t (/.f64 x (pow.f64 y #s(literal 3 binary64))))) (-.f64 y z))) t #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (* t (+ (* -1 (/ x (* (pow y 2) (- y z)))) (* t (+ (* -1 (/ x (* (pow y 3) (- y z)))) (* -1 (/ (* t x) (* (pow y 4) (- y z))))))))) (/ x (* y (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (fma.f64 (neg.f64 (/.f64 (+.f64 (/.f64 x (pow.f64 y #s(literal 3 binary64))) (.f64 t (/.f64 x (pow.f64 y #s(literal 4 binary64))))) (-.f64 y z))) t (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y z)))) t #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ x (* y (- y z)))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 x (*.f64 (-.f64 y z) y)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (/ x (* y (- y z))) (/ (* t x) (* (pow y 2) (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (fma.f64 t (/.f64 x (*.f64 y y)) (/.f64 x y)) (-.f64 y z)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (/ (* t x) (* (pow y 3) (- y z))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 3 binary64)))) (/.f64 (neg.f64 x) (.f64 (.f64 y y) (-.f64 y z)))) t (/.f64 x (.f64 (-.f64 y z) y))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (+ (* t (- (* t (- (/ (* t x) (* (pow y 4) (- y z))) (* -1 (/ x (* (pow y 3) (- y z)))))) (* -1 (/ x (* (pow y 2) (- y z)))))) (/ x (* y (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 t (-.f64 y z)) (/.f64 x (pow.f64 y #s(literal 4 binary64)))) (/.f64 (neg.f64 x) (.f64 (pow.f64 y #s(literal 3 binary64)) (-.f64 y z)))) t (.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (.f64 y y)) (-.f64 y z)))) t (/.f64 x (*.f64 (-.f64 y z) y))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (/ (pow y 2) z) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (-.f64 (/.f64 (*.f64 y y) z) y))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (- (+ (* t (+ 1 (* -1 (/ y z)))) (/ (pow y 2) z)) y)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (fma.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) t (-.f64 (/.f64 (*.f64 y y) z) y)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (- (+ 1 (+ (* -1 (/ x (* t z))) (* -1 (/ (* x (pow y 2)) (* (pow t 3) z))))) (/ (* x y) (* (pow t 2) z)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) z) #s(literal 1 binary64)) (.f64 (/.f64 y (.f64 t t)) (/.f64 x z))))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z)) t))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) z)) (*.f64 (/.f64 y t) (/.f64 x z))) t))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) z)) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) z)) t))
#s(approx (* (- y t) z) #s(hole binary64 (* t (+ (* -1 z) (/ (* y z) t)))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 y (/.f64 z t) (neg.f64 z)) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z))) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) (-.f64 y z))) t))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- y z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (neg.f64 t) (-.f64 y z)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* t (+ (* -1 (- y z)) (/ (* y (- y z)) t)))))
#s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 y (/.f64 (-.f64 y z) t) (neg.f64 (-.f64 y z))) t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (* z (+ 1 (* -1 (/ y z)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z) t))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* t (+ (* z (+ 1 (* -1 (/ y z)))) (/ (* z (- (/ (pow y 2) z) y)) t)))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) z (/.f64 (.f64 (-.f64 (/.f64 (*.f64 y y) z) y) z) t)) t))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (+ (* -1 (/ x z)) (* -1 (/ (* x y) (* t z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z)) t))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 2)) (* (pow t 2) z)))) (/ (* x y) (* t z))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) z)) (*.f64 (/.f64 y t) (/.f64 x z))) t))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (/ (- (+ (* -1 (/ x z)) (* -1 (/ (* x (pow y 3)) (* (pow t 3) z)))) (+ (/ (* x y) (* t z)) (/ (* x (pow y 2)) (* (pow t 2) z)))) t)))
#s(approx (/ x (* (- y t) z)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) z)) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) z)) t))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (+ (* -1 x) (* -1 (/ (* x y) t))) t)))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 (fma.f64 x (/.f64 y t) x)) t))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 2)) (pow t 2)))) (/ (* x y) t)) t)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (neg.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) x)) (/.f64 (.f64 y x) t)) t))
#s(approx (/ x (- y t)) #s(hole binary64 (/ (- (+ (* -1 x) (* -1 (/ (* x (pow y 3)) (pow t 3)))) (+ (/ (* x y) t) (/ (* x (pow y 2)) (pow t 2)))) t)))
#s(approx (/ x (- y t)) (/.f64 (-.f64 (neg.f64 (fma.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)) x)) (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (.f64 y x) t))) t))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (/ x (* t (- y z))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (+.f64 (/.f64 (/.f64 x t) (-.f64 y z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (/ (* x y) (* (pow t 2) (- y z)))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (fma.f64 (/.f64 y (.f64 t t)) (/.f64 x (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (.f64 (-.f64 y z) t))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (- (+ 1 (+ (/ (* x y) (* (pow t 2) (- y z))) (/ (* x (pow y 2)) (* (pow t 3) (- y z))))) (* -1 (/ x (* t (- y z)))))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (-.f64 (+.f64 (/.f64 (fma.f64 (/.f64 y t) (/.f64 x t) (/.f64 (.f64 (.f64 y y) x) (pow.f64 t #s(literal 3 binary64)))) (-.f64 y z)) #s(literal 1 binary64)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t))))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ x (* t (- y z))))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (+ (* -1 (/ x (- y z))) (* -1 (/ (* x y) (* t (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z))) t))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) (/ (* x y) (* t (- y z)))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 (/.f64 (.f64 y y) t) (/.f64 x t))) (-.f64 y z))) (*.f64 (/.f64 y (-.f64 y z)) (/.f64 x t))) t))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (/ (- (+ (* -1 (/ x (- y z))) (* -1 (/ (* x (pow y 3)) (* (pow t 3) (- y z))))) (+ (/ (* x y) (* t (- y z))) (/ (* x (pow y 2)) (* (pow t 2) (- y z))))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (-.f64 (neg.f64 (/.f64 (+.f64 x (.f64 x (pow.f64 (/.f64 y t) #s(literal 3 binary64)))) (-.f64 y z))) (/.f64 (fma.f64 (/.f64 (.f64 y y) t) (/.f64 x t) (/.f64 (*.f64 y x) t)) (-.f64 y z))) t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (+ 1 (* -1 (/ y z))))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (fma.f64 (/.f64 y z) #s(literal -1 binary64) #s(literal 1 binary64)) t))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* t (- (+ 1 (+ (* -1 (/ y z)) (/ (pow y 2) (* t z)))) (/ y t)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (-.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1 binary64) y (/.f64 (.f64 y y) t)) z) #s(literal 1 binary64)) (/.f64 y t)) t))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) t)) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) t)) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (+ (/ x (* (- y t) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t)))))
#s(approx (+ (/ x (* (- y t) z)) 1) (fma.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t)) (*.f64 x (/.f64 y z))) t) #s(literal -1 binary64) (/.f64 x z)) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z)) t))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t)) (*.f64 x (/.f64 y z))) t) #s(literal -1 binary64) (/.f64 x z)) t)))
#s(approx (/ x (* (- y t) z)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (.f64 x (/.f64 (.f64 y y) z)))) t)) (.f64 x (/.f64 y z))) t) #s(literal -1 binary64) (/.f64 x z)) t)))
#s(approx (* (- y t) z) #s(hole binary64 (* -1 (* t (+ z (* -1 (/ (* y z) t)))))))
#s(approx (* (- y t) z) (*.f64 (fma.f64 (neg.f64 y) (/.f64 z t) z) (neg.f64 t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z))) t))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 y y) t) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) t)))
#s(approx (/ x (* (- y z) (- y t))) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) t)))
#s(approx (* (- y z) (- y t)) #s(hole binary64 (* -1 (* t (- (+ y (* -1 (/ (* y (- y z)) t))) z)))))
#s(approx (* (- y z) (- y t)) (*.f64 (-.f64 (fma.f64 (neg.f64 y) (/.f64 (-.f64 y z) t) y) z) (neg.f64 t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (* z (- (/ y z) 1))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z) (neg.f64 t)))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) #s(hole binary64 (* -1 (* t (+ (* -1 (/ (* z (- (/ (pow y 2) z) y)) t)) (* z (- (/ y z) 1)))))))
#s(approx (* (+ (* (/ (- y t) z) y) (neg (- y t))) z) (.f64 (fma.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) z (.f64 (neg.f64 z) (/.f64 (-.f64 (/.f64 (*.f64 y y) z) y) t))) (neg.f64 t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (/ x z) (/ (* x y) (* t z))) t))))
#s(approx (/ x (* (- y t) z)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) z)) t))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t z))) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (.f64 (/.f64 (neg.f64 x) z) (/.f64 (.f64 y y) t)) (*.f64 x (/.f64 y z))) t) #s(literal -1 binary64) (/.f64 x z)) t)))
#s(approx (/ (/ x (- y t)) z) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t z)) (* -1 (/ (* x (pow y 2)) z))) t)) (/ (* x y) z)) t)) (/ x z)) t))))
#s(approx (/ x (* (- y t) z)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x z) (.f64 #s(literal 1 binary64) (.f64 x (/.f64 (.f64 y y) z)))) t)) (.f64 x (/.f64 y z))) t) #s(literal -1 binary64) (/.f64 x z)) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (/ (* x y) t)) t))))
#s(approx (/ x (- y t)) (/.f64 (neg.f64 (fma.f64 x (/.f64 y t) x)) t))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (* x (pow y 2)) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (neg.f64 x) (/.f64 (.f64 y y) t) (.f64 (neg.f64 y) x)) t) #s(literal -1 binary64) x) t)))
#s(approx (/ x (- y t)) #s(hole binary64 (* -1 (/ (+ x (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) t) (* -1 (* x (pow y 2)))) t)) (* x y)) t))) t))))
#s(approx (/ x (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (.f64 (.f64 y y) x)) t)) (*.f64 y x)) t) #s(literal -1 binary64) x) t)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (* x y) (* t (- y z)))) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (.f64 (neg.f64 x) (/.f64 y (.f64 (-.f64 y z) t))) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) #s(hole binary64 (+ 1 (* -1 (/ (- (* -1 (/ (+ (/ (* x y) (- y z)) (/ (* x (pow y 2)) (* t (- y z)))) t)) (/ x (- y z))) t)))))
#s(approx (- 1 (/ (/ x (- y z)) (- y t))) (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (fma.f64 x (/.f64 (.f64 y y) t) (.f64 y x)) (-.f64 y z)) t)) (/.f64 x (-.f64 y z))) t) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (/ x (- y z)) (/ (* x y) (* t (- y z)))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (/.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) x) (-.f64 y z))) t))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (* x (pow y 2)) (* t (- y z)))) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (neg.f64 x) (-.f64 y z)) (/.f64 (.f64 y y) t) (.f64 (neg.f64 x) (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) t)))
#s(approx (/ (/ x (- y z)) (- y t)) #s(hole binary64 (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (* x (pow y 3)) (* t (- y z))) (* -1 (/ (* x (pow y 2)) (- y z)))) t)) (/ (* x y) (- y z))) t)) (/ x (- y z))) t))))
#s(approx (/ (/ x (- y z)) (- y t)) (neg.f64 (/.f64 (fma.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (-.f64 (.f64 (/.f64 (pow.f64 y #s(literal 3 binary64)) t) (/.f64 x (-.f64 y z))) (/.f64 (.f64 (neg.f64 x) (.f64 y y)) (-.f64 y z))) t)) (.f64 x (/.f64 y (-.f64 y z)))) t) #s(literal -1 binary64) (/.f64 x (-.f64 y z))) t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (/ y z) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (*.f64 (-.f64 (/.f64 y z) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) #s(hole binary64 (* -1 (* t (- (+ (* -1 (/ (- (/ (pow y 2) z) y) t)) (/ y z)) 1)))))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) (.f64 (fma.f64 (/.f64 (-.f64 (/.f64 (.f64 y y) z) y) t) #s(literal -1 binary64) (-.f64 (/.f64 y z) #s(literal 1 binary64))) (neg.f64 t)))

rewrite184.0ms (2.7%)

Memory

-16.2MiB live, 234.5MiB allocated; 17ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	43	302
0	60	302
1	689	297
0	8456	292

Stop Event

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

Counts

21 → 523

Calls

Call 1

Inputs
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(/.f64 x (*.f64 (-.f64 y z) t))
(*.f64 (-.f64 y z) t)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z)))
(/.f64 x (*.f64 (-.f64 y t) z))
(*.f64 (-.f64 y t) z)
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (-.f64 y t))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
(/.f64 x #s(approx (- y z) y))
#s(approx (- y z) y)
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)

Outputs
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(.f64 (neg.f64 (sqrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64)))) (neg.f64 (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(.f64 (sqrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))) (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))))
(.f64 (cbrt.f64 (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal -1 binary64))) (pow.f64 (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))) #s(literal 3 binary64))
(pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)) #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) t))))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) t))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 3 binary64)) #s(literal -1 binary64))) (neg.f64 (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) t)))))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 3 binary64)) #s(literal -1 binary64)) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) t))))
(fma.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (.f64 (-.f64 y z) t))) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) t) (/.f64 (sqrt.f64 x) (-.f64 y z)) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y z) t))) (/.f64 (cbrt.f64 x) (sqrt.f64 (.f64 (-.f64 y z) t))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) t) (/.f64 (cbrt.f64 x) (-.f64 y z)) #s(literal 1 binary64))
(fma.f64 (/.f64 (sqrt.f64 x) (-.f64 y z)) (/.f64 (sqrt.f64 x) t) #s(literal 1 binary64))
(fma.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y z)) (/.f64 (cbrt.f64 x) t) #s(literal 1 binary64))
(fma.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t)))) (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t)))) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64))
(fma.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64)) #s(literal 1 binary64))
(fma.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64) #s(literal 1 binary64))
(cbrt.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) (-.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))))
(-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t)))) (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t)))))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t)))))
(exp.f64 (.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)))
(exp.f64 (log1p.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(+.f64 (/.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (.f64 (-.f64 y z) t)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 x (*.f64 (-.f64 y z) t)))))
(+.f64 (cosh.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y z) t)))) (sinh.f64 (log1p.f64 (/.f64 x (.f64 (-.f64 y z) t)))))
(+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) t)))
(log.f64 (exp.f64 (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))))
(.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 1 binary64)))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 (-.f64 y z) t))))
(*.f64 (/.f64 (sqrt.f64 x) t) (/.f64 (sqrt.f64 x) (-.f64 y z)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 (-.f64 y z) t))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 (-.f64 y z) t))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) t) (/.f64 (cbrt.f64 x) (-.f64 y z)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y z)) (/.f64 (sqrt.f64 x) t))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y z)) (/.f64 (cbrt.f64 x) t))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t)))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t)))))
(.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)))
(.f64 (sqrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(.f64 (cbrt.f64 (/.f64 x (.f64 (-.f64 y z) t))) (pow.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 2 binary64)))
(.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))
(/.f64 (neg.f64 (/.f64 x (-.f64 y z))) (neg.f64 t))
(/.f64 (neg.f64 (neg.f64 x)) (neg.f64 (*.f64 (neg.f64 t) (-.f64 y z))))
(/.f64 (/.f64 x (-.f64 y z)) t)
(/.f64 (neg.f64 x) (*.f64 (neg.f64 t) (-.f64 y z)))
(/.f64 x (*.f64 (-.f64 y z) t))
(neg.f64 (/.f64 (neg.f64 x) (*.f64 (-.f64 y z) t)))
(neg.f64 (/.f64 x (*.f64 (neg.f64 t) (-.f64 y z))))
(cbrt.f64 (.f64 (pow.f64 (/.f64 x (.f64 (-.f64 y z) t)) #s(literal 3 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 2 binary64)))
(exp.f64 (+.f64 (log.f64 (/.f64 x (*.f64 (-.f64 y z) t))) #s(literal 0 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 (-.f64 y z) t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 (-.f64 y z) t)))) (sinh.f64 (log.f64 (/.f64 x (.f64 (-.f64 y z) t)))))
(log.f64 (pow.f64 (E.f64) (/.f64 x (*.f64 (-.f64 y z) t))))
(log.f64 (exp.f64 (/.f64 x (*.f64 (-.f64 y z) t))))
(.f64 (.f64 (-.f64 y z) (sqrt.f64 t)) (sqrt.f64 t))
(.f64 (.f64 (-.f64 y z) (pow.f64 (cbrt.f64 t) #s(literal 2 binary64))) (cbrt.f64 t))
(.f64 (.f64 t (sqrt.f64 (-.f64 y z))) (sqrt.f64 (-.f64 y z)))
(.f64 (.f64 t (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y z)))
(.f64 (neg.f64 (sqrt.f64 (.f64 (-.f64 y z) t))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 y z) t))))
(.f64 (sqrt.f64 t) (.f64 (sqrt.f64 t) (-.f64 y z)))
(.f64 (sqrt.f64 (.f64 (-.f64 y z) t)) (sqrt.f64 (*.f64 (-.f64 y z) t)))
(.f64 (sqrt.f64 (-.f64 y z)) (.f64 (sqrt.f64 (-.f64 y z)) t))
(.f64 (pow.f64 (cbrt.f64 t) #s(literal 2 binary64)) (.f64 (cbrt.f64 t) (-.f64 y z)))
(.f64 (pow.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) #s(literal 2 binary64)) (cbrt.f64 (*.f64 (-.f64 y z) t)))
(.f64 (cbrt.f64 (.f64 (-.f64 y z) t)) (pow.f64 (cbrt.f64 (*.f64 (-.f64 y z) t)) #s(literal 2 binary64)))
(.f64 (pow.f64 (cbrt.f64 (-.f64 y z)) #s(literal 2 binary64)) (.f64 (cbrt.f64 (-.f64 y z)) t))
(*.f64 (-.f64 y z) t)
(*.f64 t (-.f64 y z))
(pow.f64 (sqrt.f64 (*.f64 (-.f64 y z) t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (-.f64 y z) t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 (-.f64 y z) t)) #s(literal 3 binary64))
(pow.f64 (*.f64 (-.f64 y z) t) #s(literal 1 binary64))
(/.f64 (.f64 t (.f64 (+.f64 y z) (-.f64 y z))) (+.f64 y z))
(/.f64 (.f64 t (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64)))) (fma.f64 y y (.f64 z (+.f64 z y))))
(cbrt.f64 (*.f64 (pow.f64 (-.f64 y z) #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 t #s(literal 3 binary64)) (pow.f64 (-.f64 y z) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 (-.f64 y z) t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 (-.f64 y z) t) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (*.f64 (-.f64 y z) t)))
(+.f64 (cosh.f64 (log.f64 (.f64 (-.f64 y z) t))) (sinh.f64 (log.f64 (.f64 (-.f64 y z) t))))
(log.f64 (pow.f64 (exp.f64 t) (-.f64 y z)))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) (pow.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64))
(pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))
(cbrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sinh.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(log.f64 (exp.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 z)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) z))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 z (-.f64 y t)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) z))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t))))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (pow.f64 (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64)))
(.f64 (/.f64 x (.f64 z (-.f64 y t))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 x)) (*.f64 z (-.f64 y t)))
(/.f64 (neg.f64 x) (*.f64 z (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (neg.f64 z)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (*.f64 z (-.f64 y t)))
(neg.f64 (/.f64 x (*.f64 z (-.f64 y t))))
(cbrt.f64 (.f64 (pow.f64 (/.f64 x (.f64 z (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 2 binary64)))
(exp.f64 (+.f64 (log.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 0 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))) (sinh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))))
(log.f64 (pow.f64 (E.f64) (/.f64 x (*.f64 z (-.f64 y t)))))
(log.f64 (exp.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (.f64 z (sqrt.f64 (-.f64 y t))) (sqrt.f64 (-.f64 y t)))
(.f64 (.f64 z (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (-.f64 y t)))
(.f64 (.f64 (-.f64 y t) (sqrt.f64 z)) (sqrt.f64 z))
(.f64 (.f64 (-.f64 y t) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z))
(.f64 (neg.f64 (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (*.f64 z (-.f64 y t))))
(.f64 (neg.f64 (sqrt.f64 (.f64 z (-.f64 y t)))) (neg.f64 (sqrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (neg.f64 (sqrt.f64 (.f64 z (-.f64 y t)))) (sqrt.f64 (*.f64 z (-.f64 y t))))
(*.f64 (neg.f64 z) (-.f64 y t))
(.f64 (sqrt.f64 z) (.f64 (sqrt.f64 z) (-.f64 y t)))
(.f64 (sqrt.f64 (-.f64 y t)) (.f64 (sqrt.f64 (-.f64 y t)) z))
(.f64 (sqrt.f64 (.f64 z (-.f64 y t))) (neg.f64 (sqrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (sqrt.f64 (.f64 z (-.f64 y t))) (sqrt.f64 (*.f64 z (-.f64 y t))))
(.f64 (pow.f64 (cbrt.f64 z) #s(literal 2 binary64)) (.f64 (cbrt.f64 z) (-.f64 y t)))
(.f64 (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64)) (.f64 (cbrt.f64 (-.f64 y t)) z))
(.f64 (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64)) (neg.f64 (cbrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64)) (cbrt.f64 (*.f64 z (-.f64 y t))))
(.f64 (cbrt.f64 (.f64 z (-.f64 y t))) (pow.f64 (cbrt.f64 (*.f64 z (-.f64 y t))) #s(literal 2 binary64)))
(*.f64 z (-.f64 y t))
(*.f64 (-.f64 y t) (neg.f64 z))
(*.f64 (-.f64 y t) z)
(pow.f64 (sqrt.f64 (*.f64 z (-.f64 y t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 z (-.f64 y t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (*.f64 z (-.f64 y t))) #s(literal 3 binary64))
(pow.f64 (*.f64 z (-.f64 y t)) #s(literal 1 binary64))
(/.f64 (.f64 z (.f64 (+.f64 y t) (-.f64 y t))) (+.f64 y t))
(/.f64 (.f64 z (-.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64)))) (fma.f64 y y (.f64 t (+.f64 t y))))
(neg.f64 (*.f64 z (-.f64 y t)))
(cbrt.f64 (*.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))))
(cbrt.f64 (*.f64 (pow.f64 (-.f64 y t) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (*.f64 z (-.f64 y t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (*.f64 z (-.f64 y t)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 z (-.f64 y t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (*.f64 z (-.f64 y t))))
(+.f64 (cosh.f64 (log.f64 (.f64 z (-.f64 y t)))) (sinh.f64 (log.f64 (.f64 z (-.f64 y t)))))
(log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 z) (-.f64 y t))))
(log.f64 (pow.f64 (exp.f64 z) (-.f64 y t)))
(.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (-.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))))
(.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (/.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))) (/.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(exp.f64 (.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))))
(+.f64 #s(literal 1 binary64) (.f64 (neg.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(+.f64 #s(literal 1 binary64) (.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) (/.f64 (cbrt.f64 x) (sqrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (neg.f64 (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(.f64 (sqrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (cbrt.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) (pow.f64 (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64)))
(.f64 #s(literal 1 binary64) (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(pow.f64 (sqrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 3 binary64))
(pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 1 binary64))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 x)) (neg.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(/.f64 (.f64 #s(literal 1 binary64) x) #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
(/.f64 (neg.f64 (neg.f64 x)) (neg.f64 (neg.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(/.f64 (neg.f64 x) (neg.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
(neg.f64 (/.f64 (neg.f64 x) #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(neg.f64 (/.f64 x (neg.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(cbrt.f64 (.f64 #s(literal 1 binary64) (pow.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(exp.f64 (.f64 (log.f64 (/.f64 x #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))) (sinh.f64 (log.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))))
(log.f64 (exp.f64 (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (neg.f64 (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) (neg.f64 (sqrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(.f64 (sqrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) (sqrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(.f64 (pow.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(.f64 (cbrt.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) (pow.f64 (cbrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 3 binary64))
(pow.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 1 binary64))
#s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))
(cbrt.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx ( (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(+.f64 (cosh.f64 (log.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))) (sinh.f64 (log.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))))
(log.f64 (exp.f64 #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) (sqrt.f64 z)) (sqrt.f64 z))
(.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 z))
(.f64 (.f64 z (sqrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t))) (sqrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (.f64 z (pow.f64 (cbrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 2 binary64))) (cbrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (neg.f64 (sqrt.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) z))) (neg.f64 (sqrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(.f64 (sqrt.f64 z) (.f64 (sqrt.f64 z) #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (sqrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) (.f64 (sqrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) z))
(.f64 (sqrt.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) z)) (sqrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
(.f64 (pow.f64 (cbrt.f64 z) #s(literal 2 binary64)) (.f64 (cbrt.f64 z) #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (pow.f64 (cbrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 2 binary64)) (.f64 (cbrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) z))
(.f64 (pow.f64 (cbrt.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 2 binary64)) (cbrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
(.f64 (cbrt.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) z)) (pow.f64 (cbrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 2 binary64)))
(.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)
(.f64 z #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t))
(pow.f64 (sqrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 3 binary64))
(pow.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z) #s(literal 1 binary64))
(cbrt.f64 (.f64 (pow.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))
(cbrt.f64 (.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) z)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z)))
(+.f64 (cosh.f64 (log.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))) (sinh.f64 (log.f64 (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(log.f64 (pow.f64 (exp.f64 z) #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (neg.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 3 binary64))
(pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))
(cbrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))))) (sinh.f64 (log.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))))
(log.f64 (exp.f64 #s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (neg.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(.f64 (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) (sqrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (pow.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) #s(literal 2 binary64)) (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t))))) (pow.f64 (cbrt.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 3 binary64))
(pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 1 binary64))
#s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))
(cbrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(+.f64 (cosh.f64 (log.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 z (-.f64 y t)))))) (sinh.f64 (log.f64 #s(approx (+ (/ x ( (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t)))))))
(log.f64 (exp.f64 #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)) (.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (cbrt.f64 z)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (sqrt.f64 z)) (/.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 z)))
(.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 z) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))))
(.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (sqrt.f64 x) z) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (sqrt.f64 x) (-.f64 y t)) (/.f64 (sqrt.f64 x) z))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (.f64 z (-.f64 y t)))) (/.f64 (cbrt.f64 x) (sqrt.f64 (*.f64 z (-.f64 y t)))))
(.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (.f64 z (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) z) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (-.f64 y t)) (/.f64 (cbrt.f64 x) z))
(.f64 (neg.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t))))) (neg.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t))))))
(.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(.f64 (sqrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 2 binary64)) (.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(.f64 (cbrt.f64 (/.f64 x (.f64 z (-.f64 y t)))) (pow.f64 (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64)))
(.f64 (/.f64 x (.f64 z (-.f64 y t))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 x)) (*.f64 z (-.f64 y t)))
(/.f64 (neg.f64 x) (*.f64 z (-.f64 y t)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 (neg.f64 z)))
(/.f64 (/.f64 x (-.f64 y t)) (neg.f64 z))
(/.f64 (/.f64 x (-.f64 y t)) z)
(/.f64 x (*.f64 z (-.f64 y t)))
(neg.f64 (/.f64 x (*.f64 z (-.f64 y t))))
(cbrt.f64 (.f64 (pow.f64 (/.f64 x (.f64 z (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1 binary64)))
(cbrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (*.f64 z (-.f64 y t))) #s(literal 2 binary64)))
(exp.f64 (+.f64 (log.f64 (/.f64 x (*.f64 z (-.f64 y t)))) #s(literal 0 binary64)))
(exp.f64 (.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))) (sinh.f64 (log.f64 (/.f64 x (.f64 z (-.f64 y t))))))
(log.f64 (pow.f64 (E.f64) (/.f64 x (*.f64 z (-.f64 y t)))))
(log.f64 (exp.f64 (/.f64 x (*.f64 z (-.f64 y t)))))
(*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 x) (sqrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))) (sqrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (neg.f64 (sqrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) (sqrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (neg.f64 (cbrt.f64 (/.f64 x (-.f64 y t)))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x (-.f64 y t))))
(*.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) (pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 x (-.f64 y t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x (-.f64 y t))) #s(literal 3 binary64))
(pow.f64 (/.f64 x (-.f64 y t)) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 x)) (-.f64 y t))
(/.f64 (neg.f64 x) (-.f64 y t))
(/.f64 x (-.f64 y t))
(neg.f64 (/.f64 x (-.f64 y t)))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 (-.f64 y t) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x (-.f64 y t)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x (-.f64 y t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x (-.f64 y t))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x (-.f64 y t)))) (sinh.f64 (log.f64 (/.f64 x (-.f64 y t)))))
(log.f64 (/.f64 #s(literal 1 binary64) (exp.f64 (/.f64 x (-.f64 y t)))))
(log.f64 (exp.f64 (/.f64 x (-.f64 y t))))
(*.f64 (+.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (-.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(*.f64 (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))) (neg.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))))
(*.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))) (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))))
(*.f64 (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) #s(literal 2 binary64)) (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(*.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) #s(literal 2 binary64)))
(pow.f64 (sin.f64 (acos.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) #s(literal 3 binary64))
(pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64))) (+.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(cbrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64)))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (/.f64 (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (/.f64 (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64)) (+.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(exp.f64 (*.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(+.f64 (cosh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))) (sinh.f64 (log.f64 (-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(log.f64 (/.f64 (E.f64) (exp.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y))) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y))) (cbrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 2 binary64)) (sqrt.f64 (-.f64 y t))) (/.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) (sqrt.f64 (-.f64 y t))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 (-.f64 y t)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 x) #s(approx (- y z) y)) (/.f64 (sqrt.f64 x) (-.f64 y t)))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) #s(approx (- y z) y)) (/.f64 (cbrt.f64 x) (-.f64 y t)))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (neg.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(*.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(*.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) (pow.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(pow.f64 (sqrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 3 binary64))
(pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 1 binary64))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 (neg.f64 x) #s(approx (- y z) y))) (-.f64 y t))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 x #s(approx (- y z) y))) (-.f64 y t))
(/.f64 (.f64 #s(literal 1 binary64) x) (.f64 #s(approx (- y z) y) (-.f64 y t)))
(/.f64 (/.f64 (neg.f64 x) #s(approx (- y z) y)) (-.f64 y t))
(/.f64 (neg.f64 x) (neg.f64 (*.f64 #s(approx (- y z) y) (-.f64 y t))))
(/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))
(/.f64 x (*.f64 #s(approx (- y z) y) (-.f64 y t)))
(neg.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(cbrt.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)) #s(literal 2 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(+.f64 (cosh.f64 (log.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))) (sinh.f64 (log.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))))
(log.f64 (exp.f64 (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t))))
(*.f64 (/.f64 (sqrt.f64 x) (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))) (/.f64 (sqrt.f64 x) (cbrt.f64 #s(approx (- y z) y))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (sqrt.f64 #s(approx (- y z) y))) (/.f64 (cbrt.f64 x) (sqrt.f64 #s(approx (- y z) y))))
(*.f64 (/.f64 (pow.f64 (cbrt.f64 x) #s(literal 2 binary64)) (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))) (cbrt.f64 (/.f64 x #s(approx (- y z) y))))
(*.f64 (neg.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y)))) (neg.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y)))))
(*.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y))) (sqrt.f64 (/.f64 x #s(approx (- y z) y))))
(*.f64 (pow.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 2 binary64)) (cbrt.f64 (/.f64 x #s(approx (- y z) y))))
(*.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) (pow.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 x #s(approx (- y z) y)) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 3 binary64))
(pow.f64 (/.f64 x #s(approx (- y z) y)) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 x)) (neg.f64 (neg.f64 #s(approx (- y z) y))))
(/.f64 (neg.f64 x) (neg.f64 #s(approx (- y z) y)))
(/.f64 x #s(approx (- y z) y))
(neg.f64 (/.f64 (neg.f64 x) #s(approx (- y z) y)))
(cbrt.f64 (/.f64 (pow.f64 x #s(literal 3 binary64)) (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64))))
(cbrt.f64 (pow.f64 (/.f64 x #s(approx (- y z) y)) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 (/.f64 x #s(approx (- y z) y)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 x #s(approx (- y z) y))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (/.f64 x #s(approx (- y z) y))))
(+.f64 (cosh.f64 (log.f64 (/.f64 x #s(approx (- y z) y)))) (sinh.f64 (log.f64 (/.f64 x #s(approx (- y z) y)))))
(log.f64 (exp.f64 (/.f64 x #s(approx (- y z) y))))
(*.f64 (neg.f64 (sqrt.f64 #s(approx (- y z) y))) (neg.f64 (sqrt.f64 #s(approx (- y z) y))))
(*.f64 (sqrt.f64 #s(approx (- y z) y)) (sqrt.f64 #s(approx (- y z) y)))
(*.f64 (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64)) (cbrt.f64 #s(approx (- y z) y)))
(*.f64 (cbrt.f64 #s(approx (- y z) y)) (pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (- y z) y)) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (- y z) y)) #s(literal 3 binary64))
(pow.f64 #s(approx (- y z) y) #s(literal 1 binary64))
#s(approx (- y z) y)
(cbrt.f64 (pow.f64 #s(approx (- y z) y) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (- y z) y) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 #s(approx (- y z) y)) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (- y z) y)))
(+.f64 (cosh.f64 (log.f64 #s(approx (- y z) y))) (sinh.f64 (log.f64 #s(approx (- y z) y))))
(log.f64 (exp.f64 #s(approx (- y z) y)))
(.f64 (neg.f64 (sqrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t))) (neg.f64 (sqrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t))))
(.f64 (sqrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) (sqrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (pow.f64 (cbrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 2 binary64)) (cbrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(.f64 (cbrt.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) (pow.f64 (cbrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 2 binary64)))
(pow.f64 (sqrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) #s(literal 3 binary64)) #s(literal 1/3 binary64))
(pow.f64 (cbrt.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 3 binary64))
(pow.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) #s(literal 1 binary64))
#s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)
(cbrt.f64 (pow.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) #s(literal 3 binary64)))
(sqrt.f64 (pow.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t)) #s(literal 1 binary64)))
(exp.f64 (log.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))
(+.f64 (cosh.f64 (log.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t))) (sinh.f64 (log.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t))))
(log.f64 (exp.f64 #s(approx (+ (* (/ (- y t) z) y) (neg (- y t))) t)))

eval306.0ms (4.6%)

Memory: 16.5MiB live, 154.8MiB allocated; 14ms collecting garbage
Compiler: Compiled 24 669 to 3 286 computations (86.7% saved)

prune27.0ms (0.4%)

Memory

14.2MiB live, 66.8MiB allocated; 9ms collecting garbage

Pruning

20 alts after pruning (12 fresh and 8 done)

	Pruned	Kept	Total
New	704	7	711
Fresh	0	5	5
Picked	0	5	5
Done	3	3	6
Total	707	20	727

Accuracy

100.0%

Counts

727 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	73.0%	(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
	68.1%	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
	70.2%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) (*.f64 (/.f64 (-.f64 y t) z) y)) z))))
✓	61.8%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
	53.6%	(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
	62.4%	(-.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t))))
	61.3%	(-.f64 #s(literal 1 binary64) #s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z)))
✓	82.5%	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
	59.5%	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
	18.9%	#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y z) t)) 1) (/.f64 (/.f64 x t) (-.f64 y z))))
✓	53.2%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
✓	16.0%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
✓	16.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
	12.8%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 (neg.f64 x) t)) z)))
	6.5%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))
✓	17.1%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
	17.0%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y))))))
	13.2%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
	6.8%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
✓	74.6%	#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Compiler

Compiled 1 306 to 490 computations (62.5% saved)

regimes98.0ms (1.5%)

Memory

-0.9MiB live, 139.5MiB allocated; 10ms collecting garbage

Counts

35 → 1

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 (neg.f64 x) t)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y z) t)) 1) (/.f64 (/.f64 x t) (-.f64 y z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z)))
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x #s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y)))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) #s(approx (- y z) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 (/.f64 x (-.f64 y t)) z) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x #s(approx (- y z) y)) (-.f64 y t)))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) t) (-.f64 y z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) (/.f64 (/.f64 (neg.f64 x) z) (-.f64 y t))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (fma.f64 (-.f64 (neg.f64 z) t) y (*.f64 t z)))))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)))
(-.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (-.f64 y z)) (-.f64 y t)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) (*.f64 (/.f64 (-.f64 y t) z) y)) z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 (fma.f64 (/.f64 (-.f64 y t) z) y (neg.f64 (-.f64 y t))) z))))
(-.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (/.f64 (sqrt.f64 (/.f64 x (-.f64 y z))) (-.f64 y t))))
(-.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (/.f64 (/.f64 x (-.f64 y t)) (-.f64 y z)) #s(literal -1 binary64)) #s(literal -1 binary64)))

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Calls

7 calls:

39.0ms	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
11.0ms	y
11.0ms	t
9.0ms	z
9.0ms	x

Results

Accuracy	Segments	Branch
99.9%	1	`(*.f64 (-.f64 y z) (-.f64 y t))`
99.9%	1	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
99.9%	1	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
99.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`

Compiler

Compiled 31 to 41 computations (-32.3% saved)

regimes72.0ms (1.1%)

Memory

-15.0MiB live, 82.6MiB allocated; 6ms collecting garbage

Counts

21 → 3

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (fma.f64 (neg.f64 z) t (*.f64 z y))))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 (neg.f64 x) t)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x z) (-.f64 y t))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 (/.f64 x (-.f64 y t)) z)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) #s(approx (+ (/ x (* (- y z) t)) 1) (/.f64 (/.f64 x t) (-.f64 y z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ (/ x (- y t)) (- y z)) (/.f64 (/.f64 x t) z)))

Outputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))

(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) #s(approx (- y t) y))))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))

Calls

7 calls:

25.0ms	z
19.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
6.0ms	y
6.0ms	t
6.0ms	x

Results

Accuracy	Segments	Branch
88.2%	3	`(*.f64 (-.f64 y z) (-.f64 y t))`
91.2%	3	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
91.2%	3	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
82.5%	1	`x`
88.4%	3	`y`
92.0%	2	`z`
95.2%	3	`t`

Compiler

Compiled 31 to 41 computations (-32.3% saved)

regimes9.0ms (0.1%)

Memory

24.1MiB live, 24.1MiB allocated; 0ms collecting garbage

Counts

14 → 2

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))

Outputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))

Calls

2 calls:

4.0ms	z
4.0ms	t

Results

Accuracy	Segments	Branch
92.0%	2	`z`
91.9%	2	`t`

Compiler

Compiled 2 to 8 computations (-300% saved)

regimes56.0ms (0.8%)

Memory

-37.2MiB live, 51.4MiB allocated; 14ms collecting garbage

Counts

12 → 3

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))

Outputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))

Calls

4 calls:

18.0ms	z
4.0ms	t
3.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
3.0ms	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Results

Accuracy	Segments	Branch
89.4%	3	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
89.4%	3	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
82.6%	2	`t`
90.5%	4	`z`

Compiler

Compiled 22 to 26 computations (-18.2% saved)

regimes17.0ms (0.2%)

Memory

30.7MiB live, 30.7MiB allocated; 0ms collecting garbage

Counts

11 → 3

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 #s(approx (- y t) y) z)) #s(literal 1 binary64)))
#s(approx (- 1 (/ (/ x (- y t)) (- y z))) (+.f64 (/.f64 x #s(approx (* (- y z) t) (*.f64 t y))) #s(literal 1 binary64)))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 t z))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (*.f64 y y))))
(-.f64 #s(literal 1 binary64) (/.f64 x #s(approx (* (- y z) (- y t)) (.f64 #s(approx (+ ( (/ (- y t) z) y) (neg (- y t))) t) z))))
(-.f64 #s(literal 1 binary64) #s(approx (/ x (* (- y z) (- y t))) #s(approx (/ (/ (neg x) t) (- y z)) (/.f64 (neg.f64 x) (*.f64 t y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 #s(approx (/ x (- y t)) (/.f64 x y)) z)))

Outputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))

Calls

5 calls:

3.0ms	y
3.0ms	z
3.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
3.0ms	(*.f64 (-.f64 y z) (-.f64 y t))
3.0ms	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Results

Accuracy	Segments	Branch
79.7%	3	`(*.f64 (-.f64 y z) (-.f64 y t))`
82.5%	3	`y`
81.8%	4	`z`
88.1%	3	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
88.1%	3	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`

Compiler

Compiled 29 to 33 computations (-13.8% saved)

regimes5.0ms (0.1%)

Memory

10.1MiB live, 10.1MiB allocated; 0ms collecting garbage

Counts

3 → 3

Calls

Call 1

Inputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))

Outputs

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))

Calls

3 calls:

1.0ms	x
1.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
1.0ms	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Results

Accuracy	Segments	Branch
74.6%	1	`x`
84.4%	3	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`
84.4%	3	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`

Compiler

Compiled 21 to 22 computations (-4.8% saved)

regimes27.0ms (0.4%)

Memory

-31.8MiB live, 18.0MiB allocated; 15ms collecting garbage

Counts

2 → 2

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 z y)))))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Calls

6 calls:

20.0ms	t
2.0ms	y
1.0ms	z
1.0ms	(*.f64 (-.f64 y z) (-.f64 y t))
1.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))

Results

Accuracy	Segments	Branch
74.6%	1	`(*.f64 (-.f64 y z) (-.f64 y t))`
74.6%	1	`z`
74.6%	1	`y`
74.6%	1	`t`
76.9%	2	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
76.9%	2	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`

Compiler

Compiled 30 to 37 computations (-23.3% saved)

regimes4.0ms (0.1%)

Memory

9.3MiB live, 9.3MiB allocated; 0ms collecting garbage

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Outputs
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Calls

4 calls:

1.0ms	z
1.0ms	(*.f64 (-.f64 y z) (-.f64 y t))
1.0ms	(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))
1.0ms	(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))

Results

Accuracy	Segments	Branch
74.6%	1	`(*.f64 (-.f64 y z) (-.f64 y t))`
74.6%	1	`z`
74.6%	1	`(/.f64 x (*.f64 (-.f64 y z) (-.f64 y t)))`
74.6%	1	`(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))`

Compiler

Compiled 28 to 29 computations (-3.6% saved)

bsearch39.0ms (0.6%)

Memory

0.3MiB live, 48.3MiB allocated; 4ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
21.0ms	8.450179440996398e-66	1.4159835334290526e-56
15.0ms	-1.845751640071347e-280	-1.010045310651624e-295

Samples

24.0ms

304×

valid

Compiler

Compiled 660 to 568 computations (13.9% saved)

Precisions

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

ival-sub: 4.0ms (44.8% of total)

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

ival-mult: 2.0ms (22.4% of total)

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

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

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

bsearch5.0ms (0.1%)

Memory

7.4MiB live, 7.4MiB allocated; 0ms collecting garbage

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
5.0ms	-1.1468391913585812e-40	-8.948992035075935e-41

Samples

3.0ms

48×

valid

Compiler

Compiled 140 to 119 computations (15% saved)

Precisions

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

ival-sub: 1.0ms (70.8% of total)

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

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

adjust: 0.0ms (0% of total)

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

exact: 0.0ms (0% of total)

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

bsearch1.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.365460483519138e-5	68.36444842961092
0.0ms	-3.308653276547143e-16	-1.9832658001768913e-19

Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.365460483519138e-5	68.36444842961092
0.0ms	-64.68412318347855	-30.807510824696656

Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	31.807510824696656	65.68412318347855
0.0ms	-67.36444842961092	0.9999863453951648

Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch0.0ms (0%)

Memory

0.5MiB live, 0.5MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-67.36444842961092	0.9999863453951648

Compiler

Compiled 14 to 17 computations (-21.4% saved)

simplify65.0ms (1%)

Memory

-17.4MiB live, 29.3MiB allocated; 3ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	69	395
1	237	395
2	296	395
3	352	395
4	431	395
5	718	395
6	3628	395
7	7822	395

Stop Event

1×	node limit

Calls

Call 1

Inputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(if (<=.f64 t #s(literal -1788272917343109/10218702384817765435680628290748613458265350453429542612493041881278524886369096016818984783322294789577433327842265575649138882500575199542984559607218336872038429045509558663769793133795138494375185186532064890845853749530218856391110938974453986086436459043203870933208875495579361330830770176 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (if (<=.f64 t #s(literal 6151454740732423/3618502788666131106986593281521497120414687020801267626233049500247285301248 binary64)) (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) #s(approx (- y t) y)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))))
(if (<=.f64 z #s(literal -5394384303847929/49039857307708443467467104868809893875799651909875269632 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))))
(if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -2028240960365167/10141204801825835211973625643008 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))))
(if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 (-.f64 y t) z)))) (if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))))
(if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (.f64 (neg.f64 z) t))))) (if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal 50 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))))
(if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (.f64 z y))))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

Outputs
(-.f64 #s(literal 1 binary64) (/.f64 x (*.f64 (-.f64 y z) (-.f64 y t))))
(if (<=.f64 t #s(literal -1788272917343109/10218702384817765435680628290748613458265350453429542612493041881278524886369096016818984783322294789577433327842265575649138882500575199542984559607218336872038429045509558663769793133795138494375185186532064890845853749530218856391110938974453986086436459043203870933208875495579361330830770176 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (if (<=.f64 t #s(literal 6151454740732423/3618502788666131106986593281521497120414687020801267626233049500247285301248 binary64)) (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) #s(approx (- y t) y)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64)))))
(if (<=.f64 t #s(literal -1788272917343109/10218702384817765435680628290748613458265350453429542612493041881278524886369096016818984783322294789577433327842265575649138882500575199542984559607218336872038429045509558663769793133795138494375185186532064890845853749530218856391110938974453986086436459043203870933208875495579361330830770176 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) (if (<=.f64 t #s(literal 6151454740732423/3618502788666131106986593281521497120414687020801267626233049500247285301248 binary64)) (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) #s(approx (- y t) y)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64)))))
(if (<=.f64 z #s(literal -5394384303847929/49039857307708443467467104868809893875799651909875269632 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal 1 binary64))))
(if (<=.f64 z #s(literal -5394384303847929/49039857307708443467467104868809893875799651909875269632 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) (-.f64 (/.f64 x (*.f64 (-.f64 y z) t)) #s(literal -1 binary64))))
(if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -2028240960365167/10141204801825835211973625643008 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) (+.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal 1 binary64))) (if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (+.f64 (/.f64 x (*.f64 (-.f64 y t) z)) #s(literal 1 binary64)))))
(if (or (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -2028240960365167/10141204801825835211973625643008 binary64)) (not (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) (-.f64 (/.f64 x (.f64 (-.f64 y t) z)) #s(literal -1 binary64))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))
(if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 (-.f64 y t) z)))) (if (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (*.f64 (-.f64 y t) z))))))
(if (or (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal -50 binary64)) (not (<=.f64 (/.f64 x (.f64 (-.f64 y z) (-.f64 y t))) #s(literal 5902958103587057/295147905179352825856 binary64)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x (.f64 (-.f64 y t) z)))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))
(if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (.f64 (neg.f64 z) t))))) (if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal 50 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64)) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (*.f64 (neg.f64 z) t)))))))
(if (or (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal -50 binary64)) (not (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal 50 binary64)))) #s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (.f64 (neg.f64 z) t))))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))
(if (<=.f64 (-.f64 #s(literal 1 binary64) (/.f64 x (.f64 (-.f64 y z) (-.f64 y t)))) #s(literal -50 binary64)) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(approx (+ (/ x (* (- y t) z)) 1) (/.f64 x #s(approx (* (- y t) z) (.f64 z y))))) #s(approx (- 1 (/ x ( (- y z) (- y t)))) #s(literal 1 binary64)))
#s(approx (- 1 (/ x (* (- y z) (- y t)))) #s(literal 1 binary64))

derivations400.0ms (6%)

Memory

15.3MiB live, 375.2MiB allocated; 154ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 395 to 73 computations (81.5% saved)

preprocess41.0ms (0.6%)

Memory: -1.5MiB live, 94.9MiB allocated; 14ms collecting garbage
Remove: (sort z t)
Compiler: Compiled 856 to 206 computations (75.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze212.0ms (3.2%)

sample1.1s (16.4%)

explain133.0ms (2%)

preprocess261.0ms (3.9%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify462.0ms (6.9%)

localize63.0ms (0.9%)

series28.0ms (0.4%)

simplify180.0ms (2.7%)

rewrite226.0ms (3.4%)

eval111.0ms (1.7%)

prune11.0ms (0.2%)

simplify181.0ms (2.7%)

localize80.0ms (1.2%)

series82.0ms (1.2%)

simplify193.0ms (2.9%)

rewrite235.0ms (3.5%)

eval154.0ms (2.3%)

prune27.0ms (0.4%)

simplify171.0ms (2.6%)

localize176.0ms (2.6%)

series90.0ms (1.3%)

simplify224.0ms (3.3%)

rewrite156.0ms (2.3%)

eval198.0ms (2.9%)

prune55.0ms (0.8%)

simplify163.0ms (2.4%)

localize112.0ms (1.7%)

series59.0ms (0.9%)

simplify210.0ms (3.1%)

rewrite184.0ms (2.7%)

eval306.0ms (4.6%)

prune27.0ms (0.4%)

regimes98.0ms (1.5%)

regimes72.0ms (1.1%)

regimes9.0ms (0.1%)

regimes56.0ms (0.8%)

regimes17.0ms (0.2%)

regimes5.0ms (0.1%)

regimes27.0ms (0.4%)

regimes4.0ms (0.1%)

bsearch39.0ms (0.6%)

bsearch5.0ms (0.1%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

simplify65.0ms (1%)

derivations400.0ms (6%)

preprocess41.0ms (0.6%)

end0.0ms (0%)

Profiling