fn parse_boards<I: Iterator<Item = S>, S: AsRef<str>>(input: &mut I) -> Vec<Vec<Vec<u8>>> {

fn parse_boards<'a, I: Iterator<Item = S>, S: AsRef<str>>(input: &'a mut I) -> impl Iterator<Item=Vec<Vec<u8>>> + 'a {

        .collect()

    let boards = parse_boards(&mut lines.flat_map(Result::ok));
    let (score,step) = boards.iter()

    let mut lines = lines.flat_map(Result::ok);
    let boards = parse_boards(&mut lines);
    let (score1,step1,score2,step2) = boards

        .min_by(|(_,a),(_,b)| a.cmp(b))
            .unwrap();
    println!("Time: {}", step);
    println!("Score: {}", score);
    let (last_called,_) = draws.iter()
        .filter(|(_,w)| *w == &step)
        .next()

        .fold(None, |acc, (score,step)| match acc {
            None => Some((score,step,score,step)),
            Some((score1,step1,score2,step2)) => {
                let (score1,step1) = if step < step1 {
                    (score,step)
                } else {
                    (score1,step1)
                };
                let (score2,step2) = if step > step2 {
                    (score,step)
                } else {
                    (score2,step2)
                };
                Some((score1,step1,score2,step2))
            }
        })

    println!("- Part 1 -");
    println!("Time: {}", step1);
    println!("Score: {}", score1);
    let (last_called,_) = draws.iter().filter(|(_,step)| **step == step1).next().unwrap();

    println!("Product: {}", score * <u8 as Into<usize>>::into(*last_called));

    println!("Product: {}", score1 * *last_called as usize);
    println!();
    println!("- Part 2 -");
    println!("Time: {}", step2);
    println!("Score: {}", score2);
    let (last_called,_) = draws.iter().filter(|(_,step)| **step == step2).next().unwrap();
    println!("Last called: {}", last_called);
    println!("Product: {}", score2 * *last_called as usize);