diff --git a/library/compiler-builtins/libm-test/src/generate/edge_cases.rs b/library/compiler-builtins/libm-test/src/generate/edge_cases.rs
index 84ef5a2a36b4..56475cbffde5 100644
--- a/library/compiler-builtins/libm-test/src/generate/edge_cases.rs
+++ b/library/compiler-builtins/libm-test/src/generate/edge_cases.rs
@@ -244,7 +244,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter1, steps1) = float_edge_cases::<Arg1<Op>>(ctx, 1);
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
-                let count = steps0.checked_mul(steps1).unwrap();
+                let count = steps0.strict_mul(steps1);
                 (iter, count)
             }
         }
@@ -263,11 +263,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                     .flat_map(move |(first, second)| {
                         iter2.clone().map(move |third| (first, second, third))
                     });
-                let count = steps0
-                    .checked_mul(steps1)
-                    .unwrap()
-                    .checked_mul(steps2)
-                    .unwrap();
+                let count = steps0.strict_mul(steps1).strict_mul(steps2);
 
                 (iter, count)
             }
@@ -283,7 +279,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
 
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
-                let count = steps0.checked_mul(steps1).unwrap();
+                let count = steps0.strict_mul(steps1);
 
                 (iter, count)
             }
@@ -299,7 +295,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
 
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
-                let count = steps0.checked_mul(steps1).unwrap();
+                let count = steps0.strict_mul(steps1);
 
                 (iter, count)
             }
@@ -336,7 +332,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter1, steps1) = int_edge_cases(ctx, 1);
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
-                let count = steps0.checked_mul(steps1).unwrap();
+                let count = steps0.strict_mul(steps1);
                 (iter, count)
             }
         }
@@ -353,7 +349,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter1, steps1) = int_edge_cases(ctx, 1);
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
-                let count = steps0.checked_mul(steps1).unwrap();
+                let count = steps0.strict_mul(steps1);
                 (iter, count)
             }
         }
diff --git a/library/compiler-builtins/libm-test/src/generate/random.rs b/library/compiler-builtins/libm-test/src/generate/random.rs
index 6ce0df458d49..4b3eaea58720 100644
--- a/library/compiler-builtins/libm-test/src/generate/random.rs
+++ b/library/compiler-builtins/libm-test/src/generate/random.rs
@@ -33,7 +33,7 @@ pub trait RandomInput: Sized {
 }
 
 /// Generate a sequence of deterministically random floats.
-fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F>
+fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F> + Clone
 where
     StandardUniform: Distribution<F::Int>,
 {
@@ -45,7 +45,7 @@ fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F>
 }
 
 /// Generate a sequence of deterministically random `i32`s within a specified range.
-fn random_ints<I>(count: u64, range: RangeInclusive<I>) -> impl Iterator<Item = I>
+fn random_ints<I>(count: u64, range: RangeInclusive<I>) -> impl Iterator<Item = I> + Clone
 where
     I: Int + SampleUniform,
 {
@@ -67,9 +67,12 @@ impl RandomInput for ($fty, $fty) {
             fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
-                let iter = random_floats(count0)
-                    .flat_map(move |f1: $fty| random_floats(count1).map(move |f2: $fty| (f1, f2)));
-                (iter, count0 * count1)
+                let iter0 = random_floats(count0);
+                let iter1 = random_floats(count1);
+                let iter =
+                    iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
+                let count = count0.strict_mul(count1);
+                (iter, count)
             }
         }
 
@@ -78,12 +81,16 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let count2 = iteration_count(ctx, 2);
-                let iter = random_floats(count0).flat_map(move |f1: $fty| {
-                    random_floats(count1).flat_map(move |f2: $fty| {
-                        random_floats(count2).map(move |f3: $fty| (f1, f2, f3))
-                    })
-                });
-                (iter, count0 * count1 * count2)
+                let iter0 = random_floats(count0);
+                let iter1 = random_floats(count1);
+                let iter2 = random_floats(count2);
+                let iter = iter0
+                    .flat_map(move |first| iter1.clone().map(move |second| (first, second)))
+                    .flat_map(move |(first, second)| {
+                        iter2.clone().map(move |third| (first, second, third))
+                    });
+                let count = count0.strict_mul(count1).strict_mul(count2);
+                (iter, count)
             }
         }
 
@@ -92,9 +99,12 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let range0 = int_range::<i32>(ctx, 0).unwrap_or(full_range());
-                let iter = random_ints(count0, range0)
-                    .flat_map(move |f1: i32| random_floats(count1).map(move |f2: $fty| (f1, f2)));
-                (iter, count0 * count1)
+                let iter0 = random_ints(count0, range0);
+                let iter1 = random_floats(count1);
+                let iter =
+                    iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
+                let count = count0.strict_mul(count1);
+                (iter, count)
             }
         }
 
@@ -103,10 +113,12 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let range1 = int_range::<i32>(ctx, 1).unwrap_or(full_range());
-                let iter = random_floats(count0).flat_map(move |f1: $fty| {
-                    random_ints(count1, range1.clone()).map(move |f2: i32| (f1, f2))
-                });
-                (iter, count0 * count1)
+                let iter0 = random_floats(count0);
+                let iter1 = random_ints(count1, range1.clone());
+                let iter =
+                    iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
+                let count = count0.strict_mul(count1);
+                (iter, count)
             }
         }
     };
@@ -136,9 +148,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count1 = iteration_count(ctx, 1);
                 let range0 = int_range::<$ity>(ctx, 0).unwrap_or(full_range());
                 let range1 = int_range::<$ity>(ctx, 1).unwrap_or(full_range());
-                let iter = random_ints(count0, range0).flat_map(move |f1: $ity| {
-                    random_ints(count1, range1.clone()).map(move |f2: $ity| (f1, f2))
-                });
+                let iter0 = random_ints(count0, range0);
+                let iter1 = random_ints(count1, range1.clone());
+                let iter =
+                    iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                 (iter, count0 * count1)
             }
         }
@@ -152,9 +165,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count1 = iteration_count(ctx, 1);
                 let range0 = int_range::<$ity>(ctx, 0).unwrap_or(full_range());
                 let range1 = int_range::<u32>(ctx, 1).unwrap_or(full_range());
-                let iter = random_ints(count0, range0).flat_map(move |f1: $ity| {
-                    random_ints(count1, range1.clone()).map(move |f2: u32| (f1, f2))
-                });
+                let iter0 = random_ints(count0, range0);
+                let iter1 = random_ints(count1, range1.clone());
+                let iter =
+                    iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                 (iter, count0 * count1)
             }
         }
diff --git a/library/compiler-builtins/libm-test/src/generate/spaced.rs b/library/compiler-builtins/libm-test/src/generate/spaced.rs
index ba04b9951272..38a8b45f1d69 100644
--- a/library/compiler-builtins/libm-test/src/generate/spaced.rs
+++ b/library/compiler-builtins/libm-test/src/generate/spaced.rs
@@ -83,11 +83,14 @@ fn total_value_count_int<I: Int>() -> Option<u64>
 }
 
 /// Returns an iterator of every possible value of type `F`.
-fn exhaustive_float<F: Float>() -> impl Iterator<Item = F>
+fn exhaustive_float<F: Float>() -> (impl Iterator<Item = F> + Clone, u64)
 where
+    u64: TryFrom<F::Int>,
     RangeInclusive<F::Int>: Iterator<Item = F::Int>,
 {
-    (F::Int::MIN..=F::Int::MAX).map(|bits| F::from_bits(bits))
+    let count = total_value_count::<F>().expect("tried exhaustive with > u64::MAX items");
+    let iter = (F::Int::MIN..=F::Int::MAX).map(|bits| F::from_bits(bits));
+    (iter, count)
 }
 
 macro_rules! impl_spaced_input {
@@ -100,10 +103,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let max_steps0 = iteration_count(ctx, 0);
 
                 // Unary tests: `f16` and `f32` may be exhaustive.
-                if let Some(steps0) = total_value_count::<Arg0<Op>>()
-                    && steps0 <= max_steps0
+                if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
+                    && exhaustive_steps0 <= max_steps0
                 {
-                    let iter0 = exhaustive_float();
+                    let (iter0, steps0) = exhaustive_float();
                     let iter0 = iter0.map(|v| (v,));
 
                     return (EitherIter::A(iter0), steps0);
@@ -125,13 +128,16 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let max_steps1 = iteration_count(ctx, 1);
 
                 // Binary test: `f16` may be exhaustive.
-                if let Some(steps0) = total_value_count::<Arg0<Op>>()
-                    && steps0 <= max_steps0
-                    && let Some(steps1) = total_value_count::<Arg1<Op>>()
-                    && steps1 <= max_steps1
+                if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
+                    && exhaustive_steps0 <= max_steps0
+                    && let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
+                    && exhaustive_steps1 <= max_steps1
                 {
-                    let iter = exhaustive_float()
-                        .flat_map(|first| exhaustive_float().map(move |second| (first, second)));
+                    let (iter0, steps0) = exhaustive_float();
+                    let (iter1, steps1) = exhaustive_float();
+
+                    let iter = iter0
+                        .flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                     let count = steps0.strict_mul(steps1);
 
                     return (EitherIter::A(iter), count);
@@ -160,18 +166,22 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
 
                 // Ternary test: `f16` may be exhaustive tested if `LIBM_EXTENSIVE_TESTS`
                 // is incresed.
-                if let Some(steps0) = total_value_count::<Arg0<Op>>()
-                    && steps0 <= max_steps0
-                    && let Some(steps1) = total_value_count::<Arg1<Op>>()
-                    && steps1 <= max_steps1
-                    && let Some(steps2) = total_value_count::<Arg2<Op>>()
-                    && steps2 <= max_steps2
+                if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
+                    && exhaustive_steps0 <= max_steps0
+                    && let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
+                    && exhaustive_steps1 <= max_steps1
+                    && let Some(exhaustive_steps2) = total_value_count::<Arg2<Op>>()
+                    && exhaustive_steps2 <= max_steps2
                 {
-                    let iter = exhaustive_float().flat_map(|first| {
-                        exhaustive_float().flat_map(move |second| {
-                            exhaustive_float().map(move |third| (first, second, third))
-                        })
-                    });
+                    let (iter0, steps0) = exhaustive_float();
+                    let (iter1, steps1) = exhaustive_float();
+                    let (iter2, steps2) = exhaustive_float();
+
+                    let iter = iter0
+                        .flat_map(move |first| iter1.clone().map(move |second| (first, second)))
+                        .flat_map(move |(first, second)| {
+                            iter2.clone().map(move |third| (first, second, third))
+                        });
                     let count = steps0.strict_mul(steps1).strict_mul(steps2);
 
                     return (EitherIter::A(iter), count);
@@ -202,15 +212,16 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let max_steps0 = iteration_count(ctx, 0);
                 let max_steps1 = iteration_count(ctx, 1);
 
-                if let Some(steps0) = total_value_count_int::<Arg0<Op>>()
-                    && steps0 <= max_steps0
-                    && let Some(steps1) = total_value_count::<Arg1<Op>>()
-                    && steps1 <= max_steps1
+                if let Some(exhaustive_steps0) = total_value_count_int::<Arg0<Op>>()
+                    && exhaustive_steps0 <= max_steps0
+                    && let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
+                    && exhaustive_steps1 <= max_steps1
                 {
                     let (iter0, steps0) = linear_ints(range0, max_steps0);
-                    let iter = iter0.flat_map(move |first| {
-                        exhaustive_float().map(move |second| (first, second))
-                    });
+                    let (iter1, steps1) = exhaustive_float();
+
+                    let iter = iter0
+                        .flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                     let count = steps0.strict_mul(steps1);
 
                     return (EitherIter::A(iter), count);
@@ -236,11 +247,13 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let range1 = int_range(ctx, 1).unwrap_or(full_range());
                 let max_steps1 = iteration_count(ctx, 1);
 
-                if let Some(steps0) = total_value_count::<Arg0<Op>>()
-                    && steps0 <= max_steps0
+                if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
+                    && exhaustive_steps0 <= max_steps0
                 {
+                    let (iter0, steps0) = exhaustive_float();
                     let (iter1, steps1) = linear_ints(range1, max_steps1);
-                    let iter = exhaustive_float()
+
+                    let iter = iter0
                         .flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                     let count = steps0.strict_mul(steps1);