pub fn solve(input: &str) {
    let transposed = input.lines().map(|line| line.as_bytes()).collect::<Vec<_>>();
    let mut lines = Vec::new();

    for idx in 0..transposed[0].len() {
        let mut line = Vec::with_capacity(transposed.len());
        for row in transposed.iter() {
            line.push(row[idx]);
        }
        lines.push(line);
    }

    let problems = lines.split(|line| {
        line[..] == [32].repeat(line.len())
    }).collect::<Vec<_>>();

    let mut sum_of_results = 0;

    for problem in problems {
        let op = problem.first().unwrap().last().unwrap();
        
        if *op == b'*' {
            let mut result = 1;

            for line in problem.iter() {
                let cleaned = line[..(line.len() - 1)].iter().filter(|byte| **byte != b' ').copied().collect::<Vec<_>>();
                // println!("cleaned: {cleaned:?}");
                let parsed = unsafe { str::from_utf8_unchecked(&cleaned) }.parse::<u64>().unwrap();
                // println!("parsed: {}", parsed);
                result *= parsed;
            }
            sum_of_results += result;
            // println!("result: {}", result);
        } else {
            let mut result = 0;

            for line in problem.iter() {
                let cleaned = line[..(line.len() - 1)].iter().filter(|byte| **byte != b' ').copied().collect::<Vec<_>>();
                // println!("cleaned: {cleaned:?}");
                let parsed = unsafe { str::from_utf8_unchecked(&cleaned) }.parse::<u64>().unwrap();
                // println!("parsed: {}", parsed);
                result += parsed;
            }
            sum_of_results += result;
            // println!("result: {}", result);
        }
    }

    println!("sum of operations: {sum_of_results}");
}