use std::fs;

fn main() {
    let input = fs::read_to_string("input.txt").unwrap();
    let mut mappers: Vec<_> = input.split("\n\n")
    .map(|maps| &maps[(maps.find(':').unwrap() + 1)..])
    .map(|maps| maps.trim())
    .map(|maps| {
        maps.split('\n')
        .map(|range| {
            range.split(' ')
            .map(|num| num.parse::<i64>().unwrap())
            .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>()
    })
    .collect();

    let seeds = mappers.first().unwrap().first().unwrap().clone();
    let mappers: &mut [Vec<Vec<i64>>] = mappers.get_mut(1..).unwrap();

    for mapper in mappers.into_iter() {
        for range in mapper {
            range[2] = range[1] + range[2] - 1;
        }
    }

    let mut cur_vals: Vec<_> = Vec::new();
    for i in 0..seeds.len() / 2 {
        let end = seeds[i * 2] + seeds[(i * 2) + 1];
        let mut range: Vec<_> = (seeds[i * 2]..end).collect();
        cur_vals.append(&mut range);
    }
    println!("{}", cur_vals.len());
    for mapper in mappers {
        for val in cur_vals.iter_mut() {
            println!("{}", val);
            for range in mapper.into_iter() {
                if range[1] <= *val && *val <= range[2] {
                    let diff = *val - range[1];
                    *val = range[0] + diff;
                    break;
                }
            }
        }
    }

    println!("{:?}", cur_vals.into_iter().min().unwrap())
}


// use std::fs;

// fn main() {
//     let input = fs::read_to_string("input.txt").unwrap();
//     let mut mappers: Vec<_> = input.split("\n\n")
//     .map(|maps| &maps[(maps.find(':').unwrap() + 1)..])
//     .map(|maps| maps.trim())
//     .map(|maps| {
//         maps.split('\n')
//         .map(|range| {
//             range.split(' ')
//             .map(|num| num.parse::<i64>().unwrap())
//             .collect::<Vec<_>>()
//         })
//         .collect::<Vec<_>>()
//     })
//     .collect();

//     let seeds = mappers.first().unwrap().first().unwrap().clone();
//     let mappers: &mut [Vec<Vec<i64>>] = mappers.get_mut(1..).unwrap();

//     for mapper in mappers.into_iter() {
//         for range in mapper {
//             range[2] = range[1] + range[2] - 1;
//         }
//     }

//     let mut cur_vals: Vec<_> = seeds;
//     for mapper in mappers {
//         for val in cur_vals.iter_mut() {
//             for range in mapper.into_iter() {
//                 if range[1] <= *val && *val <= range[2] {
//                     let diff = *val - range[1];
//                     *val = range[0] + diff;
//                     break;
//                 }
//             }
//         }
//     }

//     println!("{:?}", cur_vals.into_iter().min().unwrap())
// }