···

       
28
       
28
       
 
       
    let mut seen_ranges: HashSet<(u64, u64)> =

     

       
29
       
29
       
 
       
        HashSet::with_capacity(fresh_ranges.len());

     

       
30
       
30
       
 
       
    fresh_ranges.iter().for_each(|range| {

     

       
31
       
31
       
-
       
        let range: (u64, u64) = seen_ranges.clone().iter().fold(

     

       
31
       
31
       
+
       
        let range = seen_ranges.clone().iter().try_fold(

     

       
32
       
32
       
 
       
            *range,

     

       
33
       
33
       
 
       
            |range: (u64, u64), seen_range: &(u64, u64)| {

     

       
34
       
34
       
 
       
                // btw im refusing to ever do something better than this idc about your sorting and whatever this is the way shut the fuck up i spent three hours on this i will be using it

     
···

       
39
       
39
       
 
       
                    range.1.cmp(&seen_range.0),

     

       
40
       
40
       
 
       
                ) {

     

       
41
       
41
       
 
       
                    // if there's no touching

     

       
42
       
42
       
-
       
                    (Gt, Gt, Gt, Gt) | (Lt, Lt, Lt, Lt) => range,

     

       
42
       
42
       
+
       
                    (Gt, Gt, Gt, Gt) | (Lt, Lt, Lt, Lt) => Some(range),

     

       
43
       
43
       
 
       
                    // if it's inside of the other one

     

       
44
       
44
       
 
       
                    (Gt, Lt, _, _)

     

       
45
       
45
       
 
       
                    | (Eq, Lt, _, _)

     

       
46
       
46
       
 
       
                    | (Gt, Eq, _, _)

     

       
47
       
47
       
-
       
                    | (Eq, Eq, _, _) => (0_u64, 0_u64),

     

       
47
       
47
       
+
       
                    | (Eq, Eq, _, _) => None,

     

       
48
       
48
       
 
       
                    // if the other one is inside it

     

       
49
       
49
       
 
       
                    (Lt, Gt, _, _) | (Eq, Gt, _, _) | (Lt, Eq, _, _) => {

     

       
50
       
50
       
 
       
                        seen_ranges.remove(seen_range);

     

       
51
       
51
       
-
       
                        range

     

       
51
       
51
       
+
       
                        Some(range)

     

       
52
       
52
       
 
       
                    }

     

       
53
       
53
       
 
       
                    // if it's touching on the left side make them touch

     

       
54
       
54
       
 
       
                    (Lt, Lt, _, _) => {

     

       
55
       
55
       
 
       
                        seen_ranges.remove(seen_range);

     

       
56
       
56
       
-
       
                        (range.0, seen_range.1)

     

       
56
       
56
       
+
       
                        Some((range.0, seen_range.1))

     

       
57
       
57
       
 
       
                    }

     

       
58
       
58
       
 
       
                    // if it's touching on the right size make them touch

     

       
59
       
59
       
 
       
                    (Gt, Gt, _, _) => {

     

       
60
       
60
       
 
       
                        seen_ranges.remove(seen_range);

     

       
61
       
61
       
-
       
                        (seen_range.0, range.1)

     

       
61
       
61
       
+
       
                        Some((seen_range.0, range.1))

     

       
62
       
62
       
 
       
                    }

     

       
63
       
63
       
 
       
                }

     

       
64
       
64
       
 
       
            },

     

       
65
       
65
       
 
       
        );

     

       
66
       
66
       
 
       


     

       
67
       
67
       
-
       
        if range != (0_u64, 0_u64) {

     

       
68
       
68
       
-
       
            seen_ranges.insert(range);

     

       
67
       
67
       
+
       
        if range.is_some() {

     

       
68
       
68
       
+
       
            seen_ranges.insert(range.unwrap());

     

       
69
       
69
       
 
       
        }

     

       
70
       
70
       
 
       
    });

     

       
71
       
71
       
 
       
    let part_2 = seen_ranges