You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: simd.rs
    path of file: ./repos/optimath/benches
    
    the code of the file until where you have to start completion: use core::ops::Add;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use optimath::Vector;
use rand::{thread_rng, Rng};

#[derive(Copy, Clone)]
#[repr(transparent)]
struct Ff32(f32);

impl Add for Ff32 {
	type Output = Ff32;
	fn add(self, other: Self) -> Self { Ff32(self.0 + other.0) }
}

impl<'a, 'b> Add<&'b Ff32> for &'a Ff32 {
	type Output = Ff32;
	fn add(self, other: &'b Ff32) -> Ff32 { Ff32(self.0 + other.0) }
}

c
    
pub fn add(c: &mut Criterion) {
	let mut rng = thread_rng();
	let a: Vector<f32, TESTLEN> = rng.gen();
	let b: Vector<f32, TESTLEN> = rng.gen();

	// there seem to be two "modes" hit on optimization
	// currently "f32 simd" and "f32 inline" hit the good one
	// and "f32 noabstract" and "f32 scalar" hit the bad one
	// good one takes 180ns, bad one 320ns
	// can't inspect the asm of this specific benchmark though as the compiler just locks up
	// and eats 30 GB ram.
	// asm of benching::add and benching::internal_add seem identical and very well vectorized
	// so im assuming this a benchmarking problem
	let mut group = c.benchmark_group("addition");
	group.warm_up_time(core::time::Duration::from_millis(200));
	group.measurement_time(core::time::Duration::from_secs(2));
	group.sample_size(250);

	group.bench_function("f32 inline", |bench| bench.iter(|| &a + &b));
	group.bench_function("f32 simd", |bench| {
		bench.iter(|| optimath::benching::add(&a, &b))
	});

	group.bench_function("f32 noabstract", |bench| {
		bench.iter(|| black_box(optimath::benching::internal_add(&a, &b)))
	});

	let a: Vector<f32, TESTLEN> = rng.gen();
	let b: Vector<f32, TESTLEN> = rng.gen();
	let a: Vector<Ff32, TESTLEN> = a.into_iter().map(|f: f32| Ff32(f)).collect();
	let b: Vector<Ff32, TESTLEN> = b.into_iter().map(|f: f32| Ff32(f)).collect();

	group.bench_function("f32 scalar", |bench| bench.iter(|| black_box(&a + &b)));
}