use std::collections::HashMap;
use std::env::args;
use std::fs::File;
use std::hash::Hash;
use std::io::BufRead;
use std::io::BufReader;

fn load_data() -> Vec<[i32; 4]> {
    let path = args().nth(1).unwrap();
    let file = File::open(path).unwrap();

    let mut points: Vec<[i32; 4]> = vec![];

    for line in BufReader::new(file).lines() {
        let l = line.unwrap();
        let point: Vec<i32> = l
            .split(" -> ")
            .map(|pair| pair.split(","))
            .flatten()
            .map(|s| s.parse::<i32>().unwrap())
            .collect();
        assert_eq!(point.len(), 4);
        points.push([point[0], point[1], point[2], point[3]]);
    }

    return points;
}

fn increment<T: Eq + Hash>(map: &mut HashMap<T, i32>, key: T) {
    let i = match map.get(&key) {
        Some(v) => *v,
        None => 0,
    };
    map.insert(key, i + 1);
}

fn main() {
    let points = load_data();
    let mut map = HashMap::new();

    for point in points {
        if point[0] == point[2] {
            let (y1, y2) = if point[1] < point[3] {
                (point[1], point[3] + 1)
            } else {
                (point[3], point[1] + 1)
            };
            for y in y1..y2 {
                increment(&mut map, (point[0], y))
            }
        } else if point[1] == point[3] {
            let (x1, x2) = if point[0] < point[2] {
                (point[0], point[2] + 1)
            } else {
                (point[2], point[0] + 1)
            };
            for x in x1..x2 {
                increment(&mut map, (x, point[1]))
            }
        } else {
            // ignore
        }
    }

    let n = map.values().filter(|k| **k >= 2).count();
    print!("{}\n", n);
}