Metrics for Data.Metrics.Snapshot:quantile from metrics-0.3.0.2

start0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

analyze1.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.8%	0.2%	0%	0%	0%	0
100%	99.8%	0%	0.2%	0%	0%	0%	1

Compiler

Compiled 11 to 10 computations (9.1% saved)

sample558.0ms (11%)

Memory

242.0MiB live, 242.0MiB allocated

Samples

338.0ms

8 256×

valid

Precisions

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

ival-sub: 75.0ms (45.8% of total)

ival-mult: 47.0ms (28.7% of total)

ival-add: 33.0ms (20.1% of total)

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

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

Bogosity

explain92.0ms (1.8%)

Memory

47.4MiB live, 47.4MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
-	-	`(-.f64 t x)`
-	-	`y`
-	-	`(*.f64 (-.f64 y z) (-.f64 t x))`
-	-	`t`
-	-	`(-.f64 y z)`
-	-	`z`
-	-	`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

26.0ms

512×

valid

Compiler

Compiled 143 to 52 computations (63.6% saved)

Precisions

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

ival-sub: 5.0ms (47.2% of total)

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

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

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

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

preprocess197.0ms (3.9%)

Memory

18.6MiB live, 18.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	46	138
1	108	130
2	365	126
3	1675	126
4	4831	126
5	6641	126
0	8	9
0	12	9
1	18	9
2	38	9
3	116	9
4	392	9
5	1045	9
6	2071	9
7	3140	9
8	4192	9
9	4401	9
10	4409	9
11	4409	9
12	4453	9
13	4453	9
14	4453	9
15	4460	9
0	4460	8

Stop Event

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

Calls

Call 1

Inputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Outputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
(fma.f64 (-.f64 x t) (-.f64 z y) x)

Compiler

Compiled 9 to 8 computations (11.1% saved)

eval0.0ms (0%)

Memory: 0.2MiB live, 0.2MiB allocated
Compiler: Compiled 0 to 4 computations (-∞% saved)

prune0.0ms (0%)

Memory

0.5MiB live, 0.5MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Compiler

Compiled 9 to 8 computations (11.1% saved)

simplify145.0ms (2.9%)

Memory

12.1MiB live, 12.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(-.f64 t x)
cost-diff	0	(-.f64 y z)
cost-diff	0	(*.f64 (-.f64 y z) (-.f64 t x))
cost-diff	128	(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	26
0	12	26
1	18	26
2	38	26
3	116	26
4	392	26
5	1045	26
6	2071	26
7	3140	26
8	4192	26
9	4401	26
10	4409	26
11	4409	26
12	4453	26
13	4453	26
14	4453	26
15	4460	26
0	4460	25

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
x
(*.f64 (-.f64 y z) (-.f64 t x))
(-.f64 y z)
y
z
(-.f64 t x)
t

Outputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
x
(*.f64 (-.f64 y z) (-.f64 t x))
(*.f64 (-.f64 x t) (-.f64 z y))
(-.f64 y z)
y
z
(-.f64 t x)
t

localize17.0ms (0.3%)

Memory

7.7MiB live, 7.7MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 y z)
accuracy	0	(-.f64 t x)
accuracy	0.00390625	(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
accuracy	0.01953125	(*.f64 (-.f64 y z) (-.f64 t x))

Samples

13.0ms

256×

valid

Compiler

Compiled 54 to 18 computations (66.7% saved)

Precisions

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

ival-sub: 2.0ms (38.9% of total)

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

ival-mult: 1.0ms (19.4% of total)

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

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

series8.0ms (0.2%)

Memory

4.0MiB live, 4.0MiB allocated

Counts

4 → 144

Calls

Call 1

Inputs
#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())
#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())
#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())
#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())

Outputs
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor 0 t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor 0 y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) (patch (+.f64 x (.f64 (-.f64 y z) (-.f64 t x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor -inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt (.f64 (-.f64 y z) (-.f64 t x)) (patch (.f64 (-.f64 y z) (-.f64 t x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())

Calls

12 calls:

Time	Variable		Point	Expression
1.0ms	y	@	-inf	((+ x (* (- y z) (- t x))) (* (- y z) (- t x)) (- y z) (- t x))
1.0ms	t	@	-inf	((+ x (* (- y z) (- t x))) (* (- y z) (- t x)) (- y z) (- t x))
1.0ms	t	@	inf	((+ x (* (- y z) (- t x))) (* (- y z) (- t x)) (- y z) (- t x))
0.0ms	z	@	0	((+ x (* (- y z) (- t x))) (* (- y z) (- t x)) (- y z) (- t x))
0.0ms	z	@	-inf	((+ x (* (- y z) (- t x))) (* (- y z) (- t x)) (- y z) (- t x))

simplify108.0ms (2.1%)

Memory

34.4MiB live, 34.4MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	128	1225
1	408	885
2	1299	871
3	4924	862
0	8625	821

Stop Event

1×	iter limit
1×	node limit

Counts

144 → 138

Calls

Call 1

Inputs
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* -1 (* x (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(* -1 x)
(- t x)
(- t x)
(- t x)
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
t
(* t (+ 1 (* -1 (/ x t))))
(* t (+ 1 (* -1 (/ x t))))
(* t (+ 1 (* -1 (/ x t))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
t
(* -1 (* t (- (/ x t) 1)))
(* -1 (* t (- (/ x t) 1)))
(* -1 (* t (- (/ x t) 1)))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* y (- t x))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
y
(+ y (* -1 z))
(+ y (* -1 z))
(+ y (* -1 z))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* -1 z)
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* -1 (* z (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(* -1 z)
(- y z)
(- y z)
(- y z)
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
y
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
y
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t (- y z))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
t
(+ t (* -1 x))
(+ t (* -1 x))
(+ t (* -1 x))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* -1 (* x (- y z)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* -1 x)
(* x (- (/ t x) 1))
(* x (- (/ t x) 1))
(* x (- (/ t x) 1))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(* -1 (* x (+ 1 (* -1 (/ t x)))))

Outputs
(+ x (* -1 (* x (- y z))))
(fma.f64 (-.f64 z y) x x)
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* x (- y z)))
(*.f64 (-.f64 z y) x)
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 x)
(neg.f64 x)
(- t x)
(-.f64 t x)
(- t x)
(-.f64 t x)
(- t x)
(-.f64 t x)
(* t (- y z))
(*.f64 t (-.f64 y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* t (- y z))
(*.f64 t (-.f64 y z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(*.f64 (-.f64 x t) (-.f64 z y))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(*.f64 (-.f64 x t) (-.f64 z y))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(*.f64 (-.f64 x t) (-.f64 z y))
t
(* t (+ 1 (* -1 (/ x t))))
(-.f64 t x)
(* t (+ 1 (* -1 (/ x t))))
(-.f64 t x)
(* t (+ 1 (* -1 (/ x t))))
(-.f64 t x)
(* t (- y z))
(*.f64 t (-.f64 y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* t (- y z))
(*.f64 t (-.f64 y z))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(*.f64 (-.f64 x t) (-.f64 z y))
t
(* -1 (* t (- (/ x t) 1)))
(-.f64 t x)
(* -1 (* t (- (/ x t) 1)))
(-.f64 t x)
(* -1 (* t (- (/ x t) 1)))
(-.f64 t x)
(+ x (* y (- t x)))
(fma.f64 (-.f64 t x) y x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* y (- t x))
(*.f64 (-.f64 t x) y)
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
y
(+ y (* -1 z))
(-.f64 y z)
(+ y (* -1 z))
(-.f64 y z)
(+ y (* -1 z))
(-.f64 y z)
(* -1 (* z (- t x)))
(*.f64 (-.f64 x t) z)
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(fma.f64 (/.f64 x z) z (*.f64 (-.f64 x t) (-.f64 z y)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(fma.f64 (/.f64 x z) z (*.f64 (-.f64 x t) (-.f64 z y)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(fma.f64 (/.f64 x z) z (*.f64 (-.f64 x t) (-.f64 z y)))
(* -1 (* z (- t x)))
(*.f64 (-.f64 x t) z)
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 z)
(neg.f64 z)
(* z (- (/ y z) 1))
(-.f64 y z)
(* z (- (/ y z) 1))
(-.f64 y z)
(* z (- (/ y z) 1))
(-.f64 y z)
(* -1 (* z (- t x)))
(*.f64 (-.f64 x t) z)
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(*.f64 (-.f64 x (-.f64 t (/.f64 (fma.f64 (-.f64 t x) y x) z))) z)
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(*.f64 (-.f64 x (-.f64 t (/.f64 (fma.f64 (-.f64 t x) y x) z))) z)
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(*.f64 (-.f64 x (-.f64 t (/.f64 (fma.f64 (-.f64 t x) y x) z))) z)
(* -1 (* z (- t x)))
(*.f64 (-.f64 x t) z)
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 z)
(neg.f64 z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(-.f64 y z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(-.f64 y z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(-.f64 y z)
(+ x (* -1 (* z (- t x))))
(fma.f64 (-.f64 x t) z x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* z (- t x)))
(*.f64 (-.f64 x t) z)
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 z)
(neg.f64 z)
(- y z)
(-.f64 y z)
(- y z)
(-.f64 y z)
(- y z)
(-.f64 y z)
(* y (- t x))
(*.f64 (-.f64 t x) y)
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* y (- t x))
(*.f64 (-.f64 t x) y)
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(*.f64 (-.f64 x t) (-.f64 z y))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(*.f64 (-.f64 x t) (-.f64 z y))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(*.f64 (-.f64 x t) (-.f64 z y))
y
(* y (+ 1 (* -1 (/ z y))))
(-.f64 y z)
(* y (+ 1 (* -1 (/ z y))))
(-.f64 y z)
(* y (+ 1 (* -1 (/ z y))))
(-.f64 y z)
(* y (- t x))
(*.f64 (-.f64 t x) y)
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* y (- t x))
(*.f64 (-.f64 t x) y)
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(*.f64 (-.f64 x t) (-.f64 z y))
y
(* -1 (* y (- (/ z y) 1)))
(-.f64 y z)
(* -1 (* y (- (/ z y) 1)))
(-.f64 y z)
(* -1 (* y (- (/ z y) 1)))
(-.f64 y z)
(* t (- y z))
(*.f64 t (-.f64 y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* t (- y z))
(*.f64 t (-.f64 y z))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(*.f64 (-.f64 x t) (-.f64 z y))
t
(+ t (* -1 x))
(-.f64 t x)
(+ t (* -1 x))
(-.f64 t x)
(+ t (* -1 x))
(-.f64 t x)
(* x (+ 1 (* -1 (- y z))))
(fma.f64 (-.f64 z y) x x)
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* x (- y z)))
(*.f64 (-.f64 z y) x)
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 x)
(neg.f64 x)
(* x (- (/ t x) 1))
(-.f64 t x)
(* x (- (/ t x) 1))
(-.f64 t x)
(* x (- (/ t x) 1))
(-.f64 t x)
(* -1 (* x (- y (+ 1 z))))
(fma.f64 (-.f64 z y) x x)
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(fma.f64 (-.f64 x t) (-.f64 z y) x)
(* -1 (* x (- y z)))
(*.f64 (-.f64 z y) x)
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(*.f64 (-.f64 x t) (-.f64 z y))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(-.f64 t x)
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(-.f64 t x)
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(-.f64 t x)

rewrite120.0ms (2.4%)

Memory

45.2MiB live, 45.2MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	22
0	12	22
1	53	22
2	452	22
3	6168	22
0	8064	21

Stop Event

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

Counts

4 → 368

Calls

Call 1

Inputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
(*.f64 (-.f64 y z) (-.f64 t x))
(-.f64 y z)
(-.f64 t x)

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval48.0ms (0.9%)

Memory: 42.2MiB live, 42.2MiB allocated
Compiler: Compiled 11 355 to 1 288 computations (88.7% saved)

prune11.0ms (0.2%)

Memory

23.7MiB live, 23.7MiB allocated

Pruning

8 alts after pruning (8 fresh and 0 done)

	Pruned	Kept	Total
New	498	8	506
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	499	8	507

Accuracy

100.0%

Counts

507 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	97.3%	(fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x))
▶	63.0%	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
	56.4%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 z y) x x))
▶	56.4%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
	63.5%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 t x) y x))
▶	44.5%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
	50.9%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))
▶	50.8%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))

Compiler

Compiled 118 to 116 computations (1.7% saved)

simplify247.0ms (4.8%)

Memory

12.7MiB live, 12.7MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 17 expressions of interest:

New	Metric	Score
cost-diff	0	(-.f64 y z)
cost-diff	0	(*.f64 t (-.f64 y z))
cost-diff	0	#s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z)))
cost-diff	0	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
cost-diff	0	(-.f64 x t)
cost-diff	0	(fma.f64 (-.f64 x t) z x)
cost-diff	0	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
cost-diff	0	(-.f64 x t)
cost-diff	0	(*.f64 (-.f64 x t) z)
cost-diff	0	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
cost-diff	0	(-.f64 y z)
cost-diff	0	(*.f64 t (-.f64 y z))
cost-diff	0	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
cost-diff	0	(neg.f64 x)
cost-diff	0	(-.f64 y z)
cost-diff	128	(fma.f64 (neg.f64 x) (-.f64 y z) x)
cost-diff	384	(fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	148
0	32	148
1	55	145
2	112	145
3	352	145
4	768	145
5	1716	145
6	2840	145
7	3364	145
8	3447	145
9	3453	145
10	3453	145
11	3476	145
12	3484	145
13	3484	145
14	3535	145
15	3551	145
16	3560	145
17	3581	145
18	3588	145
19	3590	145
20	3590	145
0	3590	140

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize50.0ms (1%)

Memory

19.5MiB live, 19.5MiB allocated

Localize:

Found 17 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 y z)
accuracy	0.00390625	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
accuracy	0.0078125	(*.f64 t (-.f64 y z))
accuracy	29.550529298497448	#s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z)))
accuracy	0	(fma.f64 (-.f64 x t) z x)
accuracy	0	(-.f64 x t)
accuracy	27.876308729034875	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
accuracy	0	(-.f64 x t)
accuracy	0.0078125	(*.f64 (-.f64 x t) z)
accuracy	35.53142787701249	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
accuracy	0	(-.f64 y z)
accuracy	0.0078125	(*.f64 t (-.f64 y z))
accuracy	31.515341915190255	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
accuracy	0	(-.f64 y z)
accuracy	0	(neg.f64 x)
accuracy	0.00390625	(fma.f64 (neg.f64 x) (-.f64 y z) x)
accuracy	1.7577932332389217	(fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x))

Samples

35.0ms

256×

valid

Compiler

Compiled 230 to 36 computations (84.3% saved)

Precisions

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

ival-mult: 8.0ms (43.2% of total)

ival-add: 5.0ms (27% of total)

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

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

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

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

series30.0ms (0.6%)

Memory

12.6MiB live, 12.6MiB allocated

Counts

13 → 492

Calls

Call 1

Inputs
#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())
#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())
#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())
#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())
#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())
#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())
#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())
#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())
#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())

Outputs
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* t y))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x y))) (taylor 0 z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (* -1 t))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 x)))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 x))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 t)))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt (.f64 t (-.f64 y z)) (patch (.f64 t (-.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) (patch (fma.f64 (-.f64 y z) t (fma.f64 (neg.f64 x) (-.f64 y z) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (neg.f64 x) (-.f64 y z) x) (patch (fma.f64 (neg.f64 x) (-.f64 y z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (neg.f64 x) (patch (neg.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 x t) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 (-.f64 x t) z) (patch (.f64 (-.f64 x t) z) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt (-.f64 x t) (patch (-.f64 x t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 x t) z x) (patch (fma.f64 (-.f64 x t) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) (.f64 t (-.f64 y z))) (patch #s(approx ( (- y z) (- t x)) (*.f64 t (-.f64 y z))) #<representation binary64>) () ())) ())

Calls

12 calls:

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

simplify168.0ms (3.3%)

Memory

51.0MiB live, 51.0MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	254	5456
1	901	4858
2	2751	4303
3	7815	4303
0	8523	4049

Stop Event

1×	iter limit
1×	node limit

Counts

492 → 485

Calls

Call 1

Inputs
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* x z)
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
x
(+ x (* -1 t))
(+ x (* -1 t))
(+ x (* -1 t))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* x z))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* -1 (* x (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (/ (* x z) t)))
(* t (+ (* -1 z) (/ (* x z) t)))
(* t (+ (* -1 z) (/ (* x z) t)))
(* -1 t)
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 t)
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(+ x (+ (* -1 (* x y)) (* t y)))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (* -1 (* x y)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
y
(+ y (* -1 z))
(+ y (* -1 z))
(+ y (* -1 z))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* t y)
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
x
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* y (- t x))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(* z (+ x (* -1 t)))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* x z)
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* -1 z)
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* -1 (* t z))
(* z (+ (* -1 t) (/ (* t y) z)))
(* z (+ (* -1 t) (/ (* t y) z)))
(* z (+ (* -1 t) (/ (* t y) z)))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* -1 (* z (+ t (* -1 x))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* x z)
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* t z))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (* x z))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(* -1 z)
(- y z)
(- y z)
(- y z)
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* -1 (* z (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(* y (+ t (* -1 x)))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* -1 (* x y))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
y
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* t y)
(* y (+ t (* -1 (/ (* t z) y))))
(* y (+ t (* -1 (/ (* t z) y))))
(* y (+ t (* -1 (/ (* t z) y))))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* -1 (* y (+ x (* -1 t))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* x y))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
y
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* t y)
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 x)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(* -1 t)
(- x t)
(- x t)
(- x t)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t (- y z))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 x)
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x z)
(* x (+ z (* -1 (/ (* t z) x))))
(* x (+ z (* -1 (/ (* t z) x))))
(* x (+ z (* -1 (/ (* t z) x))))
x
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 z))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* -1 (* x (- y z)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* x z)
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
x
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))

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

rewrite165.0ms (3.2%)

Memory

61.4MiB live, 61.4MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	117
0	32	117
1	140	114
2	1219	114
0	8517	110

Stop Event

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

Counts

13 → 426

Calls

Call 1

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

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval151.0ms (3%)

Memory: 98.8MiB live, 98.8MiB allocated
Compiler: Compiled 24 577 to 1 952 computations (92.1% saved)

prune47.0ms (0.9%)

Memory

52.2MiB live, 52.2MiB allocated

Pruning

13 alts after pruning (9 fresh and 4 done)

	Pruned	Kept	Total
New	1 197	9	1 206
Fresh	3	0	3
Picked	1	4	5
Done	0	0	0
Total	1 201	13	1 214

Accuracy

100.0%

Counts

1 214 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	68.7%	(fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)))
✓	63.0%	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
▶	43.0%	(+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))))
	56.4%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x))
	50.9%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y))
✓	56.4%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
▶	37.7%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x))
✓	44.5%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
	25.7%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z))
✓	50.8%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
▶	35.0%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
	23.2%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (* (- x t) z) (*.f64 z x)))
▶	31.1%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))

Compiler

Compiled 145 to 165 computations (-13.8% saved)

simplify253.0ms (5%)

Memory

13.9MiB live, 13.9MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 18 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	32	207
0	44	207
1	78	205
2	137	205
3	304	205
4	713	205
5	1619	205
6	2940	205
7	3544	205
8	3771	205
9	3829	205
10	3846	205
11	3848	205
12	3848	205
13	3848	205
14	3881	205
15	3903	205
16	3911	205
17	3931	205
18	3938	205
19	3940	205
0	3940	198

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize62.0ms (1.2%)

Memory

24.0MiB live, 24.0MiB allocated

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 t y)
accuracy	0.00390625	(+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))))
accuracy	27.588739568855313	#s(approx (* t (- y z)) (*.f64 t y))
accuracy	29.550529298497448	#s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))
accuracy	0	(fma.f64 #s(approx (- x t) (neg.f64 t)) z x)
accuracy	0	(neg.f64 t)
accuracy	27.876308729034875	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x))
accuracy	31.15121724165456	#s(approx (- x t) (neg.f64 t))
accuracy	0	(fma.f64 z x x)
accuracy	24.757618306678935	#s(approx (+ (* (- x t) z) x) (fma.f64 z x x))
accuracy	27.876308729034875	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
accuracy	0	(*.f64 t y)
accuracy	27.588739568855313	#s(approx (* t (- y z)) (*.f64 t y))
accuracy	31.515341915190255	#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))
accuracy	0	(*.f64 (neg.f64 y) x)
accuracy	0	(neg.f64 y)
accuracy	1.7577932332389217	(fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)))
accuracy	34.47348343492368	#s(approx (+ (* (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))

Samples

44.0ms

256×

valid

Compiler

Compiled 232 to 46 computations (80.2% saved)

Precisions

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

ival-mult: 13.0ms (48% of total)

ival-add: 6.0ms (22.2% of total)

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

ival-neg: 4.0ms (14.8% of total)

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

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

series35.0ms (0.7%)

Memory

15.7MiB live, 15.7MiB allocated

Counts

17 → 576

Calls

Call 1

Inputs
#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())
#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())
#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())
#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())
#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())
#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())
#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())
#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())
#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())
#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())
#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())
#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())

Outputs
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (* -1 (/ (* x (- y z)) t))) z)) (taylor inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf t) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t)))) (taylor -inf t) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* t y))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 z)) (taylor 0 z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x y))) (taylor 0 z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (* -1 t))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (- (/ y z) 1)) (taylor inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 t) (/ (* t y) z))) (taylor inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (/ (* y (- t x)) z))) (taylor inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 x)))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ 1 (* -1 (/ y z))))) (taylor -inf z) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 (/ (* t y) z))))) (taylor -inf z) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x))) (taylor -inf z) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (- y z) (taylor 0 y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* t y)) (taylor 0 y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* z (- t x))) (* y (- t x))) (taylor 0 y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 x))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ z y)))) (taylor inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 (/ (* t z) y)))) (taylor inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (* -1 (/ (* z (- t x)) y))) x)) (taylor inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 t)))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ z y) 1))) (taylor -inf y) (#s(alt (-.f64 y z) (patch (-.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 t) (/ (* t z) y)))) (taylor -inf y) (#s(alt #s(approx (* t (- y z)) (.f64 t y)) (patch #s(approx ( t (- y z)) (*.f64 t y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf y) (#s(alt (.f64 t y) (patch (.f64 t y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y)))) (taylor -inf y) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor 0 x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x (- y z))) (* t (- y z))) (taylor 0 x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (- y z)) (/ (* t (- y z)) x))) (taylor inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x))) (patch (fma.f64 (-.f64 y z) t #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (neg x) (- y z)) x) (.f64 (neg.f64 y) x)) (patch #s(approx (+ ( (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf x) (#s(alt (.f64 (neg.f64 y) x) (patch (.f64 (neg.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (patch #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) (patch #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 z x x) (patch (fma.f64 z x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (patch #s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) (patch (fma.f64 #s(approx (- x t) (neg.f64 t)) z x) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt (+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y)))) (patch (+.f64 x #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z))) (taylor -inf x) (#s(alt #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (.f64 t y))) (patch #s(approx ( (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))) #<representation binary64>) () ())) ())

Calls

12 calls:

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

simplify158.0ms (3.1%)

Memory

48.7MiB live, 48.7MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	250	5852
1	877	5254
2	2661	4687
3	7726	4687
0	8426	4394

Stop Event

1×	iter limit
1×	node limit

Counts

576 → 567

Calls

Call 1

Inputs
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t y)
(* t y)
(* t y)
(* t y)
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* x z))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* x z))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
x
(+ x (* -1 t))
(+ x (* -1 t))
(+ x (* -1 t))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* -1 (* x (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t y)
(* t y)
(* t y)
(* t y)
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* -1 t)
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- (+ y (* -1 (/ (* x (- y z)) t))) z))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t (- y z))
(* t y)
(* t y)
(* t y)
(* t y)
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 t)
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(* -1 (* t (+ (* -1 (- y z)) (/ (* x (- y z)) t))))
(+ x (+ (* -1 (* x y)) (* t y)))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
y
(+ y (* -1 z))
(+ y (* -1 z))
(+ y (* -1 z))
(+ x (* -1 (* x y)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* t y)
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
x
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* z (- x t)))
x
(+ x (* x z))
(+ x (* x z))
(+ x (* x z))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
x
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* y (- t x))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(* z (+ x (* -1 t)))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* -1 z)
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* z (- (/ y z) 1))
(* x z)
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* -1 (* t z))
(* z (+ (* -1 t) (/ (* t y) z)))
(* z (+ (* -1 t) (/ (* t y) z)))
(* z (+ (* -1 t) (/ (* t y) z)))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* x z)
(* z (+ x (/ x z)))
(* z (+ x (/ x z)))
(* z (+ x (/ x z)))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* z (+ (* -1 (- t x)) (/ (* y (- t x)) z)))
(* -1 (* z (+ t (* -1 x))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* -1 (* z (+ 1 (* -1 (/ y z)))))
(* x z)
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* t z))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (+ t (* -1 (/ (* t y) z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* x z)
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (* y (- t x)) z))) x)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(* -1 z)
(- y z)
(- y z)
(- y z)
(+ x (* x z))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(+ (* -1 (* t z)) (* t y))
(* t y)
(* t y)
(* t y)
(* t y)
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* -1 (* z (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(+ (* -1 (* z (- t x))) (* y (- t x)))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(* y (+ t (* -1 x)))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
y
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* y (+ 1 (* -1 (/ z y))))
(* -1 (* x y))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* t y)
(* y (+ t (* -1 (/ (* t z) y))))
(* y (+ t (* -1 (/ (* t z) y))))
(* y (+ t (* -1 (/ (* t z) y))))
(* t y)
(* t y)
(* t y)
(* t y)
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* y (- (+ t (* -1 (/ (* z (- t x)) y))) x))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 (* y (+ x (* -1 t))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
y
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* -1 (* y (- (/ z y) 1)))
(* -1 (* x y))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* t y)
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* -1 (* y (+ (* -1 t) (/ (* t z) y))))
(* t y)
(* t y)
(* t y)
(* t y)
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 (* y (+ (* -1 (- t x)) (/ (* z (- t x)) y))))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(* -1 t)
(- x t)
(- x t)
(- x t)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t (- y z))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(+ (* -1 (* x (- y z))) (* t (- y z)))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (* -1 (- y z))))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 z))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 z))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
x
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* -1 (* x (- y z)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* x (+ (* -1 (- y z)) (/ (* t (- y z)) x)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x y))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
x
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- y z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) z)))

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

rewrite143.0ms (2.8%)

Memory

51.4MiB live, 51.4MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	32	181
0	44	181
1	183	179
2	1428	179
0	8357	174

Stop Event

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

Counts

17 → 231

Calls

Call 1

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

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval104.0ms (2%)

Memory: 70.3MiB live, 70.3MiB allocated
Compiler: Compiled 12 265 to 1 035 computations (91.6% saved)

prune34.0ms (0.7%)

Memory

37.5MiB live, 37.5MiB allocated

Pruning

13 alts after pruning (4 fresh and 9 done)

	Pruned	Kept	Total
New	860	1	861
Fresh	1	3	4
Picked	0	5	5
Done	0	4	4
Total	861	13	874

Accuracy

100.0%

Counts

874 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	68.7%	(fma.f64 (-.f64 y z) t #s(approx (+ (* (neg x) (- y z)) x) (*.f64 (neg.f64 y) x)))
✓	63.0%	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
✓	43.0%	(+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))))
▶	56.4%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x))
▶	50.9%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y))
✓	56.4%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
✓	37.7%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x))
✓	44.5%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
▶	25.7%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z))
✓	50.8%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
✓	35.0%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
▶	23.2%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))))
✓	31.1%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))

Compiler

Compiled 87 to 98 computations (-12.6% saved)

simplify170.0ms (3.3%)

Memory

12.5MiB live, 12.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 14 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	32	158
0	40	158
1	75	148
2	150	148
3	413	148
4	913	148
5	1980	148
6	3261	148
7	3618	148
8	3695	148
9	3703	148
10	3704	148
11	3706	148
12	3706	148
13	3747	148
14	3747	148
15	3747	148
0	3747	139

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize56.0ms (1.1%)

Memory

21.6MiB live, 21.6MiB allocated

Localize:

Found 14 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 z y)
accuracy	0.00390625	(fma.f64 (-.f64 z y) x x)
accuracy	27.887974483166182	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x))
accuracy	0	(-.f64 t x)
accuracy	0.0078125	(*.f64 (-.f64 t x) y)
accuracy	31.414888693078307	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y))
accuracy	0	(neg.f64 t)
accuracy	0.0078125	(*.f64 #s(approx (- x t) (neg.f64 t)) z)
accuracy	31.15121724165456	#s(approx (- x t) (neg.f64 t))
accuracy	35.53142787701249	#s(approx (+ x (* (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z))
accuracy	0	(*.f64 z x)
accuracy	24.757618306678935	#s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))
accuracy	27.876308729034875	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))))
accuracy	30.69563968292476	#s(approx (+ (* z x) x) (*.f64 z x))

Samples

41.0ms

256×

valid

Compiler

Compiled 175 to 43 computations (75.4% saved)

Precisions

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

ival-mult: 11.0ms (42.4% of total)

ival-add: 7.0ms (27% of total)

ival-sub: 5.0ms (19.3% of total)

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

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

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

series29.0ms (0.6%)

Memory

13.7MiB live, 13.7MiB allocated

Counts

14 → 468

Calls

Call 1

Inputs
#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())
#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())
#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())
#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())
#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())
#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())
#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())
#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())
#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())

Outputs
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 t)) (taylor 0 t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor 0 t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (- t x) (taylor 0 t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x (- y z))) (* t (- y z)))) (taylor 0 t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t)))) (taylor inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (* -1 z) (/ (* x z) t))) (taylor inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- (/ x t) 1)) (taylor inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* t (+ y (* -1 (/ (* x y) t)))) (taylor inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* t (+ y (* -1 (/ (* x y) t)))) (taylor inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* t (+ y (* -1 (/ (* x y) t)))) (taylor inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (* -1 (/ x t)))) (taylor inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z)) (taylor inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor -inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ z (* -1 (/ (* x z) t))))) (taylor -inf t) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ 1 (* -1 (/ x t))))) (taylor -inf t) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor -inf t) (#s(alt (neg.f64 t) (patch (neg.f64 t) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor -inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 y) (/ (* x y) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 y) (/ (* x y) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 y) (/ (* x y) t)))) (taylor -inf t) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (/ x t) 1))) (taylor -inf t) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t))))) (taylor -inf t) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ x (* z (- x t))) (taylor 0 z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (+ x (* y (- t x))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor 0 z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* t y))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* t y))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t)))))) (taylor 0 z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* x y))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (- z y) (taylor 0 z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (- z y) (taylor 0 z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (- z y) (taylor 0 z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* z (- (+ x (/ x z)) t)) (taylor inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (/ x z))) (taylor inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z)))) (taylor inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (* -1 t))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (* -1 t))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z)))))) (taylor inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (* -1 (/ y z)))) (taylor inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (* -1 (/ y z)))) (taylor inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (* -1 (/ y z)))) (taylor inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ x z))))) (taylor -inf z) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- t x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x))) (taylor -inf z) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* z (- x t)) (taylor -inf z) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 x)))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (* -1 x)))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z)))))) (taylor -inf z) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z))))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (/ y z) 1))) (taylor -inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (/ y z) 1))) (taylor -inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (/ y z) 1))) (taylor -inf z) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 (* z (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* z (- t x))) (* y (- t x)))) (taylor 0 y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor 0 y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (* x z))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x)))))) (taylor 0 y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ x (* x z)) (taylor 0 y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* -1 (* x y)) (* x z))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt z (taylor 0 y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 y)) (taylor 0 y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 y)) (taylor 0 y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 y)) (taylor 0 y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x)) (taylor inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 x))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (* -1 x))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y)))))) (taylor inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ z y) 1)) (taylor inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ z y) 1)) (taylor inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ z y) 1)) (taylor inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y))))) (taylor -inf y) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 t)))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* y (- t x)) (taylor -inf y) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 t)))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y)))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ z y))))) (taylor -inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ z y))))) (taylor -inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ z y))))) (taylor -inf y) (#s(alt (-.f64 z y) (patch (-.f64 z y) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x (+ 1 z))) (taylor 0 x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor 0 x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor 0 x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t z)) (taylor 0 x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* t z)) (* x z)) (taylor 0 x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (- x t) (taylor 0 x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* t y) (taylor 0 x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* x y)) (* t y)) (taylor 0 x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 x)) (taylor 0 x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* t (- y z)) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (+ (* t (- y z)) (* x (+ 1 (* -1 (- y z))))) (taylor 0 x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor 0 x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ z (* -1 (/ (* t z) x))))) (taylor inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 z)) (taylor inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ z (* -1 (/ (* t z) x)))) (taylor inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ t x)))) (taylor inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 y) (/ (* t y) x))) (taylor inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 y) (/ (* t y) x))) (taylor inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 y) (/ (* t y) x))) (taylor inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ t x) 1)) (taylor inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (- y z)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x)))) (taylor inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* x (- (+ 1 z) y)) (taylor inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x)))) (patch #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (.f64 z x))) (patch #s(approx (+ ( (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 z) 1))) (taylor -inf x) (#s(alt #s(approx (+ (* z x) x) (.f64 z x)) (patch #s(approx (+ ( z x) x) (*.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 z x) (patch (.f64 z x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (patch #s(approx (+ x ( (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z)) #<representation binary64>) () ())) ())
#s(alt (* x z) (taylor -inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 z) (/ (* t z) x)))) (taylor -inf x) (#s(alt (.f64 #s(approx (- x t) (neg.f64 t)) z) (patch (.f64 #s(approx (- x t) (neg.f64 t)) z) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ t x) 1))) (taylor -inf x) (#s(alt #s(approx (- x t) (neg.f64 t)) (patch #s(approx (- x t) (neg.f64 t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 (-.f64 t x) y)) (patch #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x y)) (taylor -inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ y (* -1 (/ (* t y) x))))) (taylor -inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ y (* -1 (/ (* t y) x))))) (taylor -inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ y (* -1 (/ (* t y) x))))) (taylor -inf x) (#s(alt (.f64 (-.f64 t x) y) (patch (.f64 (-.f64 t x) y) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ t x))))) (taylor -inf x) (#s(alt (-.f64 t x) (patch (-.f64 t x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- y (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z)))) (taylor -inf x) (#s(alt #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) (patch #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (- z y)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (- z y)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (- z y)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (- z y)) 1))) (taylor -inf x) (#s(alt (fma.f64 (-.f64 z y) x x) (patch (fma.f64 (-.f64 z y) x x) #<representation binary64>) () ())) ())

Calls

12 calls:

Time	Variable		Point	Expression
2.0ms	x	@	-inf	((+ x (* (- y z) (- t x))) (+ (* (- x t) z) x) (+ (* z x) x) (* z x) (+ x (* (- y z) (- t x))) (* (- x t) z) (- x t) (neg t) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (* (- t x) y) (- t x) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (+ (* (- z y) x) x) (- z y))
1.0ms	x	@	inf	((+ x (* (- y z) (- t x))) (+ (* (- x t) z) x) (+ (* z x) x) (* z x) (+ x (* (- y z) (- t x))) (* (- x t) z) (- x t) (neg t) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (* (- t x) y) (- t x) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (+ (* (- z y) x) x) (- z y))
1.0ms	z	@	-inf	((+ x (* (- y z) (- t x))) (+ (* (- x t) z) x) (+ (* z x) x) (* z x) (+ x (* (- y z) (- t x))) (* (- x t) z) (- x t) (neg t) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (* (- t x) y) (- t x) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (+ (* (- z y) x) x) (- z y))
1.0ms	z	@	inf	((+ x (* (- y z) (- t x))) (+ (* (- x t) z) x) (+ (* z x) x) (* z x) (+ x (* (- y z) (- t x))) (* (- x t) z) (- x t) (neg t) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (* (- t x) y) (- t x) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (+ (* (- z y) x) x) (- z y))
1.0ms	x	@	0	((+ x (* (- y z) (- t x))) (+ (* (- x t) z) x) (+ (* z x) x) (* z x) (+ x (* (- y z) (- t x))) (* (- x t) z) (- x t) (neg t) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (* (- t x) y) (- t x) (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (+ (* (- z y) x) x) (- z y))

simplify144.0ms (2.8%)

Memory

43.6MiB live, 43.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	247	4325
1	878	3892
2	2662	3712
3	7496	3712
0	8141	3484

Stop Event

1×	iter limit
1×	node limit

Counts

468 → 457

Calls

Call 1

Inputs
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (* x z))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* x z)
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
x
(+ x (* -1 t))
(+ x (* -1 t))
(+ x (* -1 t))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* -1 (* x y))
(+ (* -1 (* x y)) (* t y))
(+ (* -1 (* x y)) (* t y))
(+ (* -1 (* x y)) (* t y))
(* -1 x)
(- t x)
(- t x)
(- t x)
(+ x (* -1 (* x (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(+ x (+ (* -1 (* x (- y z))) (* t (- y z))))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (+ (* -1 z) (+ (/ x t) (/ (* x z) t))))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* -1 (* t z))
(* t (+ (* -1 z) (/ (* x z) t)))
(* t (+ (* -1 z) (/ (* x z) t)))
(* t (+ (* -1 z) (/ (* x z) t)))
(* -1 t)
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* t (- (/ x t) 1))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t y)
(* t (+ y (* -1 (/ (* x y) t))))
(* t (+ y (* -1 (/ (* x y) t))))
(* t (+ y (* -1 (/ (* x y) t))))
t
(* t (+ 1 (* -1 (/ x t))))
(* t (+ 1 (* -1 (/ x t))))
(* t (+ 1 (* -1 (/ x t))))
(* t (- y z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- (+ y (+ (* -1 (/ (* x (- y z)) t)) (/ x t))) z))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* -1 (* t (+ z (* -1 (/ (+ x (* x z)) t)))))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t z))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 (* t (+ z (* -1 (/ (* x z) t)))))
(* -1 t)
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 (* t (+ 1 (* -1 (/ x t)))))
(* -1 t)
(* -1 t)
(* -1 t)
(* -1 t)
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* t y)
(* -1 (* t (+ (* -1 y) (/ (* x y) t))))
(* -1 (* t (+ (* -1 y) (/ (* x y) t))))
(* -1 (* t (+ (* -1 y) (/ (* x y) t))))
t
(* -1 (* t (- (/ x t) 1)))
(* -1 (* t (- (/ x t) 1)))
(* -1 (* t (- (/ x t) 1)))
(* t (- y z))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(* -1 (* t (+ (* -1 (- y z)) (* -1 (/ (+ x (* -1 (* x (- y z)))) t)))))
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
x
(+ x (* z (- x t)))
(+ x (* z (- x t)))
(+ x (* z (- x t)))
x
(+ x (* x z))
(+ x (* x z))
(+ x (* x z))
(* x z)
(* x z)
(* x z)
(* x z)
(+ x (* y (- t x)))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(+ x (+ (* -1 (* x y)) (* t y)))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (* t y)))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (+ (* -1 (* x y)) (+ (* t y) (* z (+ x (* -1 t))))))
(+ x (* -1 (* x y)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(* -1 y)
(- z y)
(- z y)
(- z y)
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* z (- (+ x (/ x z)) t))
(* x z)
(* z (+ x (/ x z)))
(* z (+ x (/ x z)))
(* z (+ x (/ x z)))
(* x z)
(* x z)
(* x z)
(* x z)
(* -1 (* z (- t x)))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (+ (* -1 (- t x)) (+ (/ x z) (/ (* y (- t x)) z))))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (+ x (* -1 t)))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (* -1 t)))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* z (+ x (+ (* -1 t) (+ (* -1 (/ (* x y) z)) (+ (/ x z) (/ (* t y) z))))))
(* x z)
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
(* z (+ x (+ (* -1 (/ (* x y) z)) (/ x z))))
z
(* z (+ 1 (* -1 (/ y z))))
(* z (+ 1 (* -1 (/ y z))))
(* z (+ 1 (* -1 (/ y z))))
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 (- x t)) (* -1 (/ x z)))))
(* x z)
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ x z)))))
(* x z)
(* x z)
(* x z)
(* x z)
(* -1 (* z (- t x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* -1 (* z (- (+ t (* -1 (/ (+ x (* y (- t x))) z))) x)))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* z (- x t))
(* -1 (* z (+ t (* -1 x))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (* -1 x))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* -1 (* z (+ t (+ (* -1 x) (* -1 (/ (+ x (+ (* -1 (* x y)) (* t y))) z))))))
(* x z)
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
(* -1 (* z (+ (* -1 x) (* -1 (/ (+ x (* -1 (* x y))) z)))))
z
(* -1 (* z (- (/ y z) 1)))
(* -1 (* z (- (/ y z) 1)))
(* -1 (* z (- (/ y z) 1)))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (* -1 (* z (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* z (- t x))) (* y (- t x))))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(+ x (+ (* -1 (* t z)) (* x z)))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (+ (* -1 (* t z)) (+ (* x z) (* y (+ t (* -1 x))))))
(+ x (* x z))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
(+ x (+ (* -1 (* x y)) (* x z)))
z
(+ z (* -1 y))
(+ z (* -1 y))
(+ z (* -1 y))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- t x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (- (+ t (+ (* -1 (/ (* z (- t x)) y)) (/ x y))) x))
(* y (+ t (* -1 x)))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(* y (+ t (* -1 x)))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* y (+ t (+ (* -1 x) (+ (* -1 (/ (* t z) y)) (+ (/ x y) (/ (* x z) y))))))
(* -1 (* x y))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* y (+ (* -1 x) (+ (/ x y) (/ (* x z) y))))
(* -1 y)
(* y (- (/ z y) 1))
(* y (- (/ z y) 1))
(* y (- (/ z y) 1))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* y (- t x))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ (* -1 (- t x)) (* -1 (/ (+ x (* -1 (* z (- t x)))) y)))))
(* -1 (* y (+ x (* -1 t))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(* y (- t x))
(* -1 (* y (+ x (* -1 t))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* y (+ x (+ (* -1 t) (* -1 (/ (+ x (+ (* -1 (* t z)) (* x z))) y))))))
(* -1 (* x y))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 (* y (+ x (* -1 (/ (+ x (* x z)) y)))))
(* -1 y)
(* -1 (* y (+ 1 (* -1 (/ z y)))))
(* -1 (* y (+ 1 (* -1 (/ z y)))))
(* -1 (* y (+ 1 (* -1 (/ z y)))))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(+ (* -1 (* t z)) (* x (+ 1 z)))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x z)
(* x z)
(* x z)
(* x z)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* -1 (* t z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(+ (* -1 (* t z)) (* x z))
(* -1 t)
(- x t)
(- x t)
(- x t)
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* t y)
(+ (* -1 (* x y)) (* t y))
(+ (* -1 (* x y)) (* t y))
(+ (* -1 (* x y)) (* t y))
t
(+ t (* -1 x))
(+ t (* -1 x))
(+ t (* -1 x))
(* t (- y z))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(+ (* t (- y z)) (* x (+ 1 (* -1 (- y z)))))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 z))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 (+ z (* -1 (/ (* t z) x)))))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x (+ 1 z))
(* x z)
(* x z)
(* x z)
(* x z)
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x z)
(* x (+ z (* -1 (/ (* t z) x))))
(* x (+ z (* -1 (/ (* t z) x))))
(* x (+ z (* -1 (/ (* t z) x))))
x
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (/ t x))))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* -1 (* x y))
(* x (+ (* -1 y) (/ (* t y) x)))
(* x (+ (* -1 y) (/ (* t y) x)))
(* x (+ (* -1 y) (/ (* t y) x)))
(* -1 x)
(* x (- (/ t x) 1))
(* x (- (/ t x) 1))
(* x (- (/ t x) 1))
(* x (+ 1 (* -1 (- y z))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (+ 1 (+ (* -1 (- y z)) (/ (* t (- y z)) x))))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* x (- (+ 1 z) y))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (+ (* -1 z) (/ (* t z) x)) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* -1 (* x (- (* -1 z) 1)))
(* x z)
(* x z)
(* x z)
(* x z)
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* x z)
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
(* -1 (* x (+ (* -1 z) (/ (* t z) x))))
x
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- (/ t x) 1)))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x y))
(* -1 (* x (+ y (* -1 (/ (* t y) x)))))
(* -1 (* x (+ y (* -1 (/ (* t y) x)))))
(* -1 (* x (+ y (* -1 (/ (* t y) x)))))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(* -1 (* x (+ 1 (* -1 (/ t x)))))
(* -1 (* x (- y (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (+ y (* -1 (/ (* t (- y z)) x))) (+ 1 z))))
(* -1 (* x (- (* -1 (- z y)) 1)))
(* -1 (* x (- (* -1 (- z y)) 1)))
(* -1 (* x (- (* -1 (- z y)) 1)))
(* -1 (* x (- (* -1 (- z y)) 1)))

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

rewrite139.0ms (2.7%)

Memory

50.0MiB live, 50.0MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	32	148
0	40	148
1	178	138
2	1527	138
0	8193	129

Stop Event

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

Counts

14 → 163

Calls

Call 1

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

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval76.0ms (1.5%)

Memory: 50.9MiB live, 50.9MiB allocated
Compiler: Compiled 7 684 to 866 computations (88.7% saved)

prune34.0ms (0.7%)

Memory

33.0MiB live, 33.0MiB allocated

Pruning

15 alts after pruning (3 fresh and 12 done)

	Pruned	Kept	Total
New	617	3	620
Fresh	0	0	0
Picked	0	4	4
Done	1	8	9
Total	618	15	633

Accuracy

100.0%

Counts

633 → 15

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	63.0%	(+.f64 x #s(approx (* (- y z) (- t x)) (*.f64 t (-.f64 y z))))
✓	43.0%	(+.f64 x #s(approx (* (- y z) (- t x)) #s(approx (* t (- y z)) (*.f64 t y))))
✓	56.4%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 (-.f64 z y) x x))
	39.3%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 #s(approx (- z y) (neg.f64 y)) x x))
	49.0%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (fma.f64 y t (*.f64 y (neg.f64 x))))
✓	50.9%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 (-.f64 t x) y))
	26.9%	#s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 #s(approx (- t x) (neg.f64 x)) y))
✓	56.4%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
✓	37.7%	#s(approx (+ x (* (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x))
✓	44.5%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
✓	25.7%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 #s(approx (- x t) (neg.f64 t)) z))
✓	50.8%	#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
✓	35.0%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
✓	23.2%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))))
✓	31.1%	#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))

Compiler

Compiled 252 to 175 computations (30.6% saved)

regimes45.0ms (0.9%)

Memory

19.9MiB live, 19.9MiB allocated

Counts

22 → 1

Calls

Call 1

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

Outputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Calls

6 calls:

8.0ms	(-.f64 y z)
7.0ms	t
7.0ms	y
7.0ms	x
7.0ms	z

Results

Accuracy	Segments	Branch
100.0%	1	`x`
100.0%	1	`y`
100.0%	1	`z`
100.0%	1	`t`
100.0%	1	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
100.0%	1	`(-.f64 y z)`

Compiler

Compiled 16 to 29 computations (-81.3% saved)

regimes41.0ms (0.8%)

Memory

18.5MiB live, 18.5MiB allocated

Counts

19 → 3

Calls

Call 1

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

Outputs
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))
#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 x t) z x))
#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 t x) y x))

Calls

6 calls:

7.0ms	(-.f64 y z)
7.0ms	t
7.0ms	y
7.0ms	x
6.0ms	z

Results

Accuracy	Segments	Branch
85.1%	3	`x`
89.2%	3	`y`
86.7%	3	`z`
81.1%	3	`t`
70.7%	3	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
76.3%	6	`(-.f64 y z)`

Compiler

Compiled 16 to 29 computations (-81.3% saved)

regimes12.0ms (0.2%)

Memory

5.9MiB live, 5.9MiB allocated

Counts

14 → 3

Calls

Call 1

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

Outputs
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
#s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 t x) y x))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))

Calls

2 calls:

5.0ms	y
5.0ms	z

Results

Accuracy	Segments	Branch
86.6%	3	`z`
82.0%	4	`y`

Compiler

Compiled 2 to 8 computations (-300% saved)

regimes21.0ms (0.4%)

Memory

10.7MiB live, 10.7MiB allocated

Counts

13 → 4

Calls

Call 1

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

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

Calls

4 calls:

5.0ms	t
5.0ms	y
5.0ms	z
5.0ms	x

Results

Accuracy	Segments	Branch
80.7%	4	`y`
67.2%	5	`t`
72.1%	4	`x`
78.6%	5	`z`

Compiler

Compiled 4 to 16 computations (-300% saved)

regimes5.0ms (0.1%)

Memory

2.7MiB live, 2.7MiB allocated

Counts

9 → 5

Calls

Call 1

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

Outputs
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))

Calls

1 calls:

4.0ms

Results

Accuracy	Segments	Branch
81.1%	5	`y`

Compiler

Compiled 1 to 4 computations (-300% saved)

regimes8.0ms (0.2%)

Memory

4.6MiB live, 4.6MiB allocated

Counts

8 → 5

Calls

Call 1

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

Outputs
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 t (-.f64 y z)))
#s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 t x) y))

Calls

2 calls:

4.0ms	y
4.0ms	z

Results

Accuracy	Segments	Branch
60.8%	3	`z`
76.6%	5	`y`

Compiler

Compiled 2 to 8 computations (-300% saved)

regimes14.0ms (0.3%)

Memory

8.3MiB live, 8.3MiB allocated

Counts

7 → 4

Calls

Call 1

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

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

Calls

4 calls:

3.0ms	y
3.0ms	(-.f64 y z)
3.0ms	x
3.0ms	(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Results

Accuracy	Segments	Branch
67.2%	4	`x`
50.8%	1	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
57.5%	3	`(-.f64 y z)`
59.0%	3	`y`

Compiler

Compiled 14 to 21 computations (-50% saved)

regimes19.0ms (0.4%)

Memory

11.7MiB live, 11.7MiB allocated

Counts

6 → 5

Calls

Call 1

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

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

Calls

6 calls:

3.0ms	t
3.0ms	y
3.0ms	(-.f64 y z)
3.0ms	x
3.0ms	z

Results

Accuracy	Segments	Branch
40.3%	3	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
46.3%	4	`(-.f64 y z)`
56.4%	5	`y`
47.5%	4	`z`
52.5%	3	`t`
55.1%	6	`x`

Compiler

Compiled 16 to 29 computations (-81.3% saved)

regimes3.0ms (0.1%)

Memory

2.2MiB live, 2.2MiB allocated

Counts

5 → 4

Calls

Call 1

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

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

Calls

1 calls:

3.0ms

Results

Accuracy	Segments	Branch
54.4%	4	`y`

Compiler

Compiled 1 to 4 computations (-300% saved)

regimes3.0ms (0.1%)

Memory

2.1MiB live, 2.1MiB allocated

Counts

4 → 3

Calls

Call 1

Inputs
#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (* (- x t) z) (*.f64 z x)))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) #s(approx (+ (* z x) x) (*.f64 z x))))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x)))

Outputs

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

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

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

Calls

1 calls:

3.0ms

Results

Accuracy	Segments	Branch
52.7%	3	`y`

Compiler

Compiled 1 to 4 computations (-300% saved)

regimes12.0ms (0.2%)

Memory

8.6MiB live, 8.6MiB allocated

Counts

3 → 3

Calls

Call 1

Inputs

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

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

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

Outputs

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

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

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

Calls

5 calls:

2.0ms	y
2.0ms	t
2.0ms	x
2.0ms	(-.f64 y z)
2.0ms	z

Results

Accuracy	Segments	Branch
31.1%	1	`(-.f64 y z)`
44.4%	3	`z`
39.7%	3	`x`
43.2%	3	`t`
41.9%	3	`y`

Compiler

Compiled 7 to 21 computations (-200% saved)

regimes9.0ms (0.2%)

Memory

7.4MiB live, 7.4MiB allocated

Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts

1 → 1

Calls

Call 1

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

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

Calls

5 calls:

2.0ms	x
2.0ms	z
2.0ms	y
2.0ms	t
2.0ms	(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))

Results

Accuracy	Segments	Branch
31.1%	1	`x`
31.1%	1	`(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))`
31.1%	1	`y`
31.1%	1	`t`
31.1%	1	`z`

Compiler

Compiled 13 to 24 computations (-84.6% saved)

bsearch27.0ms (0.5%)

Memory

8.1MiB live, 8.1MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
13.0ms	1.4173890954333493e-7	0.20729878721190778
11.0ms	-422835250105398000.0	-763593513727040.5

Samples

14.0ms

272×

valid

Compiler

Compiled 242 to 287 computations (-18.6% saved)

Precisions

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

ival-sub: 3.0ms (46.5% of total)

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

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

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

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

bsearch24.0ms (0.5%)

Memory

7.1MiB live, 7.1MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
10.0ms	23045167.726735327	3089495105.8891535
11.0ms	-3.770613585856643e+26	-1.2370097490202149e+23

Samples

12.0ms

240×

valid

Compiler

Compiled 207 to 255 computations (-23.2% saved)

Precisions

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

ival-sub: 3.0ms (52.4% of total)

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

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

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

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

bsearch34.0ms (0.7%)

Memory

10.2MiB live, 10.2MiB allocated

Algorithm

3×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
11.0ms	0.20729878721190778	97.66963010771944
11.0ms	5.291380760968121e-273	7.918538751871306e-269
7.0ms	-422835250105398000.0	-763593513727040.5

Samples

17.0ms

336×

valid

Compiler

Compiled 316 to 415 computations (-31.3% saved)

Precisions

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

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

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

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

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

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

bsearch30.0ms (0.6%)

Memory

9.6MiB live, 9.6MiB allocated

Algorithm

4×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	0.20729878721190778	97.66963010771944
13.0ms	-1.83310327567736e-280	-9.374991697511338e-290
9.0ms	-3.025031499690113e-106	-6.006688645569003e-107
5.0ms	-422835250105398000.0	-763593513727040.5

Samples

15.0ms

288×

valid

Compiler

Compiled 384 to 511 computations (-33.1% saved)

Precisions

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

ival-sub: 3.0ms (43.6% of total)

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

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

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

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

bsearch22.0ms (0.4%)

Memory

7.0MiB live, 7.0MiB allocated

Algorithm

4×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
6.0ms	0.20729878721190778	97.66963010771944
12.0ms	2.6386931173173126e-150	9.50395594827405e-148
1.0ms	-3.025031499690113e-106	-6.006688645569003e-107
1.0ms	-422835250105398000.0	-763593513727040.5

Samples

10.0ms

192×

valid

Compiler

Compiled 372 to 495 computations (-33.1% saved)

Precisions

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

ival-sub: 2.0ms (43.5% of total)

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

ival-mult: 1.0ms (21.8% of total)

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

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

bsearch40.0ms (0.8%)

Memory

11.8MiB live, 11.8MiB allocated

Algorithm

3×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
10.0ms	3.0673951735863344e+165	5.512810759966582e+167
13.0ms	7.014555214059765e+71	6.537947921599058e+80
13.0ms	-1.9053921982453561e+92	-4.513948091234536e+82

Samples

21.0ms

400×

valid

Compiler

Compiled 312 to 422 computations (-35.3% saved)

Precisions

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

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

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

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

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

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

bsearch26.0ms (0.5%)

Memory

8.0MiB live, 8.0MiB allocated

Algorithm

4×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
12.0ms	3.531768663827763e+153	1.107442332224352e+158
1.0ms	0.20729878721190778	97.66963010771944
8.0ms	2.6386931173173126e-150	9.50395594827405e-148
3.0ms	-7.750128858860656e+45	-6.697164531778406e+45

Samples

13.0ms

240×

valid

Compiler

Compiled 314 to 463 computations (-47.5% saved)

Precisions

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

ival-sub: 3.0ms (51.8% of total)

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

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

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

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

bsearch7.0ms (0.1%)

Memory

2.3MiB live, 2.3MiB allocated

Algorithm

3×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
4.0ms	1.2880148154474548e-14	1.7460888134250454e-14
1.0ms	2.6386931173173126e-150	9.50395594827405e-148
0.0ms	-7.750128858860656e+45	-6.697164531778406e+45

Samples

3.0ms

48×

valid

Compiler

Compiled 163 to 234 computations (-43.6% saved)

Precisions

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

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

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

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

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

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

bsearch12.0ms (0.2%)

Memory

3.6MiB live, 3.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
10.0ms	5.549508898824871e+59	1.2545785708548905e+62
0.0ms	-7.750128858860656e+45	-6.697164531778406e+45

Samples

6.0ms

112×

valid

Compiler

Compiled 111 to 159 computations (-43.2% saved)

Precisions

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

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

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

ival-mult: 1.0ms (36.4% of total)

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

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

bsearch12.0ms (0.2%)

Memory

3.9MiB live, 3.9MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	23045167.726735327	3089495105.8891535
10.0ms	-1489539115931404800.0	-7689194032705429.0

Samples

6.0ms

112×

valid

Compiler

Compiled 152 to 239 computations (-57.2% saved)

Precisions

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

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

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

ival-mult: 1.0ms (36.1% of total)

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

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

simplify35.0ms (0.7%)

Memory

20.0MiB live, 20.0MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	121	843
1	140	843
2	149	843
3	153	843
4	154	843

Stop Event

1×

saturated

Calls

Call 1

Inputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
(if (<=.f64 y #s(literal -2700000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal 3246626956972881/36893488147419103232 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 t x) y x))))
(if (<=.f64 z #s(literal -140000000000000008388608 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (if (<=.f64 z #s(literal 2500000000 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 (-.f64 t x) y x)) #s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))))
(if (<=.f64 y #s(literal -780000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal 4609752416281127/74350845423889153139903124907495028006563010082969722952788592965797032858020218677258415724807817529489936189509648652522729262277245285389541529055119731289148542022372993697134320491714886843511959789117571860303387435343894004407854947017432904150602255272707195641188267440734208 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (if (<=.f64 y #s(literal 45 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y)))))
(if (<=.f64 y #s(literal -3500000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal -6197399707408581/20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947008 binary64)) #s(approx (+ x ( (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 y #s(literal -5722473335497949/40874809539271061742722513162994453833061401813718170449972167525114099545476384067275939133289179158309733311369062302596555530002300798171938238428873347488153716182038234655079172535180553977500740746128259563383414998120875425564443755897815944345745836172815483732835501982317445323323080704 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 45 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y))))))
(if (<=.f64 y #s(literal -3500000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal -6197399707408581/20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947008 binary64)) #s(approx (+ x ( (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 y #s(literal 3599131035634557/14396524142538228424993723224595141948383030778566133225922417832357880258148761185020930195532450742879746914027266864394266451377581759004827248578768524336431104 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 59/2 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y))))))
(if (<=.f64 x #s(literal -100000000000000003080666323096525690777025204007643346346089744069413985291331436544 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 x #s(literal 24499999999999999505861799784218972503809878799581577787224769733138055168 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 x #s(literal 379999999999999993721717938684107504977313735970497093840301457684979433169607666331493791677346896052583262545093383349812265283855037874537591936353280861820185214976 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 #s(approx (- t x) (neg.f64 x)) y)))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 6838348967705659/7198262071269114212496861612297570974191515389283066612961208916178940129074380592510465097766225371439873457013633432197133225688790879502413624289384262168215552 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 59/2 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (if (<=.f64 y #s(literal 380000000000000005108673117317708614502657882206222443035520544855956334316242777162531925831371834610731815469388147747294940629484994911226570500617535488 binary64)) #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 #s(approx (- t x) (neg.f64 x)) y)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 6838348967705659/7198262071269114212496861612297570974191515389283066612961208916178940129074380592510465097766225371439873457013633432197133225688790879502413624289384262168215552 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 5387515050969975/316912650057057350374175801344 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 559999999999999957384318839301851754916781511672558277099520 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))))
(if (<=.f64 z #s(literal -1020000000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* (- x t) z) (.f64 z x))) (if (<=.f64 z #s(literal 2500000000 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* (- x t) z) (*.f64 z x)))))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))

Outputs
(+.f64 x (*.f64 (-.f64 y z) (-.f64 t x)))
(+.f64 (*.f64 (-.f64 t x) (-.f64 y z)) x)
(if (<=.f64 y #s(literal -2700000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal 3246626956972881/36893488147419103232 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 (-.f64 x t) z x)) #s(approx (+ x (* (- y z) (- t x))) (fma.f64 (-.f64 t x) y x))))
(if (<=.f64 z #s(literal -140000000000000008388608 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) (if (<=.f64 z #s(literal 2500000000 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 (-.f64 t x) y x)) #s(approx (+ x (* (- y z) (- t x))) (*.f64 (-.f64 x t) z))))
(if (<=.f64 y #s(literal -780000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal 4609752416281127/74350845423889153139903124907495028006563010082969722952788592965797032858020218677258415724807817529489936189509648652522729262277245285389541529055119731289148542022372993697134320491714886843511959789117571860303387435343894004407854947017432904150602255272707195641188267440734208 binary64)) #s(approx (+ x ( (- y z) (- t x))) (fma.f64 #s(approx (- x t) (neg.f64 t)) z x)) (if (<=.f64 y #s(literal 45 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y)))))
(if (<=.f64 y #s(literal -3500000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal -6197399707408581/20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947008 binary64)) #s(approx (+ x ( (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 y #s(literal -5722473335497949/40874809539271061742722513162994453833061401813718170449972167525114099545476384067275939133289179158309733311369062302596555530002300798171938238428873347488153716182038234655079172535180553977500740746128259563383414998120875425564443755897815944345745836172815483732835501982317445323323080704 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 45 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 x t) z)) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y))))))
(if (<=.f64 y #s(literal -3500000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 (-.f64 t x) y)) (if (<=.f64 y #s(literal -6197399707408581/20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947008 binary64)) #s(approx (+ x ( (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 y #s(literal 3599131035634557/14396524142538228424993723224595141948383030778566133225922417832357880258148761185020930195532450742879746914027266864394266451377581759004827248578768524336431104 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 59/2 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) #s(approx (+ x ( (- y z) (- t x))) (*.f64 (-.f64 t x) y))))))
(if (<=.f64 x #s(literal -100000000000000003080666323096525690777025204007643346346089744069413985291331436544 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 x #s(literal 24499999999999999505861799784218972503809878799581577787224769733138055168 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 t (-.f64 y z))) (if (<=.f64 x #s(literal 379999999999999993721717938684107504977313735970497093840301457684979433169607666331493791677346896052583262545093383349812265283855037874537591936353280861820185214976 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #s(approx (+ (* (- y z) t) (+ (* (neg x) (- y z)) x)) (*.f64 #s(approx (- t x) (neg.f64 x)) y)))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 6838348967705659/7198262071269114212496861612297570974191515389283066612961208916178940129074380592510465097766225371439873457013633432197133225688790879502413624289384262168215552 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 59/2 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) (if (<=.f64 y #s(literal 380000000000000005108673117317708614502657882206222443035520544855956334316242777162531925831371834610731815469388147747294940629484994911226570500617535488 binary64)) #s(approx (+ ( (- y z) t) (+ (* (neg x) (- y z)) x)) (.f64 #s(approx (- t x) (neg.f64 x)) y)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 6838348967705659/7198262071269114212496861612297570974191515389283066612961208916178940129074380592510465097766225371439873457013633432197133225688790879502413624289384262168215552 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) (if (<=.f64 y #s(literal 5387515050969975/316912650057057350374175801344 binary64)) #s(approx (+ x (* (- y z) (- t x))) (.f64 #s(approx (- x t) (neg.f64 t)) z)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y))))))
(if (<=.f64 y #s(literal -7399999999999999543586468792974549102322778112 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) (if (<=.f64 y #s(literal 559999999999999957384318839301851754916781511672558277099520 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (+ (* (- x t) z) x) (fma.f64 z x x))) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))))
(if (<=.f64 z #s(literal -1020000000000000000 binary64)) #s(approx (+ x (* (- y z) (- t x))) #s(approx (* (- x t) z) (.f64 z x))) (if (<=.f64 z #s(literal 2500000000 binary64)) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* t (- y z)) (.f64 t y))) #s(approx (+ x ( (- y z) (- t x))) #s(approx (* (- x t) z) (*.f64 z x)))))
#s(approx (+ x (* (- y z) (- t x))) #s(approx (* t (- y z)) (*.f64 t y)))

soundness928.0ms (18.2%)

Memory

20.8MiB live, 20.8MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	128	1225
1	408	885
2	1299	871
3	4924	862
0	8625	821
0	8	22
0	12	22
1	53	22
2	452	22
3	6168	22
0	8064	21
0	247	4325
1	878	3892
2	2662	3712
3	7496	3712
0	8141	3484
0	254	5456
1	901	4858
2	2751	4303
3	7815	4303
0	8523	4049

Stop Event

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

Compiler

Compiled 561 to 378 computations (32.6% saved)

preprocess98.0ms (1.9%)

Memory: 61.2MiB live, 61.2MiB allocated
Compiler: Compiled 764 to 252 computations (67% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze1.0ms (0%)

sample558.0ms (11%)

explain92.0ms (1.8%)

preprocess197.0ms (3.9%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify145.0ms (2.9%)

localize17.0ms (0.3%)

series8.0ms (0.2%)

simplify108.0ms (2.1%)

rewrite120.0ms (2.4%)

eval48.0ms (0.9%)

prune11.0ms (0.2%)

simplify247.0ms (4.8%)

localize50.0ms (1%)

series30.0ms (0.6%)

simplify168.0ms (3.3%)

rewrite165.0ms (3.2%)

eval151.0ms (3%)

prune47.0ms (0.9%)

simplify253.0ms (5%)

localize62.0ms (1.2%)

series35.0ms (0.7%)

simplify158.0ms (3.1%)

rewrite143.0ms (2.8%)

eval104.0ms (2%)

prune34.0ms (0.7%)

simplify170.0ms (3.3%)

localize56.0ms (1.1%)

series29.0ms (0.6%)

simplify144.0ms (2.8%)

rewrite139.0ms (2.7%)

eval76.0ms (1.5%)

prune34.0ms (0.7%)

regimes45.0ms (0.9%)

regimes41.0ms (0.8%)

regimes12.0ms (0.2%)

regimes21.0ms (0.4%)

regimes5.0ms (0.1%)

regimes8.0ms (0.2%)

regimes14.0ms (0.3%)

regimes19.0ms (0.4%)

regimes3.0ms (0.1%)

regimes3.0ms (0.1%)

regimes12.0ms (0.2%)

regimes9.0ms (0.2%)

bsearch27.0ms (0.5%)

bsearch24.0ms (0.5%)

bsearch34.0ms (0.7%)

bsearch30.0ms (0.6%)

bsearch22.0ms (0.4%)

bsearch40.0ms (0.8%)

bsearch26.0ms (0.5%)

bsearch7.0ms (0.1%)

bsearch12.0ms (0.2%)

bsearch12.0ms (0.2%)

simplify35.0ms (0.7%)

soundness928.0ms (18.2%)

preprocess98.0ms (1.9%)

end0.0ms (0%)

Profiling