use std::io::{self, BufRead};

#[derive(Debug)]
struct Layer {
    depth: usize,
    range: usize,
}

impl Layer {
    fn new(depth: usize, range: usize) -> Layer {
        Layer { depth, range }
    }

    fn is_scanner_at(&self, delta: usize, index: usize) -> bool {
        let time = self.depth + delta;
        let c = (self.range - 1) * 2;

        time % c == index || time % c == (c - index)
    }

    fn severity(&self) -> usize {
        self.depth * self.range
    }
}

fn main() {
    let stdin = io::stdin();

    let firewall = stdin
        .lock()
        .lines()
        .filter_map(Result::ok)
        .map(|line| {
            let digits = line
                .split(": ")
                .map(|digit| digit.parse::<usize>().expect("failed to parse digit"))
                .collect::<Vec<_>>();

            Layer::new(digits[0], digits[1])
        }).collect::<Vec<_>>();

    let mut severity = 0;

    for layer in &firewall {
        if layer.is_scanner_at(0, 0) {
            severity += layer.severity();
        }
    }

    println!("part.one={}", severity);

    let mut delta = 0;

    'iteration: loop {
        for layer in &firewall {
            if layer.is_scanner_at(delta, 0) {
                delta += 1;

                continue 'iteration;
            }
        }

        break;
    }

    println!("part.two={}", delta);
}