diff --git a/benches/parabole.rs b/benches/parabole.rs
index d5b3b57..4e7ba68 100644
--- a/benches/parabole.rs
+++ b/benches/parabole.rs
@@ -63,64 +63,74 @@ impl Individual for Parabole {
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let initial = (0..1000)
-        .map(|i| Parabole { x: i as f64 })
-        .collect::<Vec<_>>();
+    c.bench_function("calculate", move |b| {
+        let initial = (0..1000)
+            .map(|i| Parabole { x: f64::from(i) })
+            .collect::<Vec<_>>();
 
-    let population_size = initial.len();
+        let mut simulation = Simulation::with_population(initial);
 
-    let mut simulation = Simulation::with_population(initial);
-
-    c.bench_function("calculate", |b| b.iter(|| {
-        simulation.calculate();
-    }));
-
-    c.bench_function("evolve", |b| b.iter(|| {
-        simulation.evolve(|parents, population| {
-            // Mate top 10 to get 5 children.
-            parents
-                .iter()
-                .enumerate()
-                .filter(|&(n, _)| n % 2 == 0)
-                .map(|(_, wrapper)| wrapper)
-                .take(5)
-                .zip(
-                    parents
-                        .iter()
-                        .enumerate()
-                        .filter(|&(n, _)| n % 2 == 1)
-                        .map(|(_, wrapper)| wrapper)
-                        .take(5),
-                )
-                .map(|(a, b)| a.individual.mate(&b.individual))
-                .map(|individual| {
-                    Wrapper {
-                        individual: individual,
-                        fitness: None,
-                    }
-                })
-                .for_each(|wrapper| { population.push(wrapper); });
-
-            // Mutate all to get new children.
-            parents
-                .par_iter()
-                .map(|wrapper| wrapper.individual.clone())
-                .map(|mut individual| {
-                    individual.mutate();
-
-                    Wrapper {
-                        individual: individual,
-                        fitness: None,
-                    }
-                })
-                .collect_into(population);
-
-            // Add all parents again.
-            population.extend(parents.iter().cloned());
+        b.iter(|| {
+            simulation.calculate();
         });
+    });
 
-        simulation.population.truncate(population_size);
-    }));
+    c.bench_function("evolve", move |b| {
+        let initial = (0..1000)
+            .map(|i| Parabole { x: f64::from(i) })
+            .collect::<Vec<_>>();
+
+        let population_size = initial.len();
+
+        let mut simulation = Simulation::with_population(initial);
+
+        b.iter(|| {
+            simulation.evolve(|parents, population| {
+                // Mate top 10 to get 5 children.
+                parents
+                    .iter()
+                    .enumerate()
+                    .filter(|&(n, _)| n % 2 == 0)
+                    .map(|(_, wrapper)| wrapper)
+                    .take(5)
+                    .zip(
+                        parents
+                            .iter()
+                            .enumerate()
+                            .filter(|&(n, _)| n % 2 == 1)
+                            .map(|(_, wrapper)| wrapper)
+                            .take(5),
+                    )
+                    .map(|(a, b)| a.individual.mate(&b.individual))
+                    .map(|individual| {
+                        Wrapper {
+                            individual: individual,
+                            fitness: None,
+                        }
+                    })
+                    .for_each(|wrapper| { population.push(wrapper); });
+
+                // Mutate all to get new children.
+                parents
+                    .par_iter()
+                    .map(|wrapper| wrapper.individual.clone())
+                    .map(|mut individual| {
+                        individual.mutate();
+
+                        Wrapper {
+                            individual: individual,
+                            fitness: None,
+                        }
+                    })
+                    .collect_into(population);
+
+                // Add all parents again.
+                population.extend(parents.iter().cloned());
+            });
+
+            simulation.population.truncate(population_size);
+        });
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);