fix 32-bit

rene-d · rene-d · commit 8a080a5e1b8b · 2024-02-06T06:48:06.000+01:00
diff --git a/2016/day9/day9.rs b/2016/day9/day9.rs
@@ -9,12 +9,12 @@ fn main() {
 }
 
 /// Do part 1 of the puzzle
-fn part1(data: &str) -> usize {
-    data.split('\n').fold(0, |acc, line| acc + expand_v1(line).len())
+fn part1(data: &str) -> u64 {
+    data.split('\n').fold(0, |acc, line| acc + expand_v1(line).len() as u64)
 }
 
 /// Do part 2 of the puzzle
-fn part2(data: &str) -> usize {
+fn part2(data: &str) -> u64 {
     data.split('\n').fold(0, |acc, line| acc + expand_v2(line))
 }
 
@@ -53,12 +53,12 @@ fn expand_v1(s: &str) -> String {
 }
 
 /// ``expand_v2`` returns the length of expanded string according to the format v2.
-fn expand_v2(s: &str) -> usize {
+fn expand_v2(s: &str) -> u64 {
     expand(s, 2)
 }
 
 /// ``expand`` returns the length of the expanded string (v1 or v2).
-fn expand(s: &str, version: u8) -> usize {
+fn expand(s: &str, version: u8) -> u64 {
     let mut new_len = 0;
     let mut chars = s.chars();
 
@@ -76,13 +76,13 @@ fn expand(s: &str, version: u8) -> usize {
                 .by_ref()
                 .take_while(|c| *c != ')')
                 .collect::<String>()
-                .parse::<usize>()
+                .parse::<u64>()
                 .unwrap();
 
             let taken = chars.by_ref().take(take);
 
             let count = if version == 1 {
-                taken.count()
+                taken.count() as u64
             } else {
                 expand(taken.collect::<String>().as_str(), version)
             };
@@ -101,7 +101,7 @@ fn expand(s: &str, version: u8) -> usize {
 fn test_expand_v1() {
     fn test_v1(s: &str, expected: &str) {
         assert_eq!(expand_v1(s), expected);
-        assert_eq!(expand(s, 1), expected.len());
+        assert_eq!(expand(s, 1), expected.len() as u64);
     }
     test_v1("ADVENT", "ADVENT");
     test_v1("A(1x5)BC", "ABBBBBC");
diff --git a/2020/day23/day23.rs b/2020/day23/day23.rs
@@ -20,7 +20,7 @@ impl Puzzle {
             .collect();
     }
 
-    fn solve(&self, nb_cups: usize, nb_moves: usize) -> usize {
+    fn solve(&self, nb_cups: usize, nb_moves: usize) -> u64 {
         // cups are labeled from 1 to 9 (and from 10 to ncups), cup no. 0 is *unused*
 
         let cups = |i: usize| {
@@ -68,26 +68,26 @@ impl Puzzle {
 
         if nb_cups > self.cups.len() {
             // answer for part 2
-            (pos[pos[1]]) * (pos[1])
+            (pos[pos[1]] as u64) * (pos[1] as u64)
         } else {
             // answer for part 1
             let mut result = 0;
             let mut cup = pos[1];
             while cup != 1 {
-                result = result * 10 + cup;
+                result = result * 10 + cup as u64;
                 cup = pos[cup];
             }
             result
         }
     }
 
     /// Solve part one.
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u64 {
         self.solve(self.cups.len(), 100)
     }
 
     /// Solve part two.
-    fn part2(&self) -> usize {
+    fn part2(&self) -> u64 {
         self.solve(1_000_000, 10_000_000)
     }
 }
diff --git a/2022/day11/day11.cpp b/2022/day11/day11.cpp
@@ -91,7 +91,7 @@ void solve(const std::vector<Monkey> &monkeys_orig, int rounds)
               {
                   return a.inspections > b.inspections;
               });
-    uint64_t monkey_business_level = monkeys[0].inspections * monkeys[1].inspections;
+    uint64_t monkey_business_level = (uint64_t)monkeys[0].inspections * (uint64_t)monkeys[1].inspections;
 
     std::cout << monkey_business_level << std::endl;
 }
diff --git a/2022/day11/day11.rs b/2022/day11/day11.rs
@@ -112,17 +112,17 @@ impl Puzzle {
     }
 
     /// Solves part one
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u64 {
         self.solve(20)
     }
 
     /// Solve part two
-    fn part2(&self) -> usize {
+    fn part2(&self) -> u64 {
         self.solve(10000)
     }
 
     /// Solve the puzzle
-    fn solve(&self, rounds: usize) -> usize {
+    fn solve(&self, rounds: usize) -> u64 {
         // we need to clone the monkeys array since we modify the starting item lists
         let mut monkeys = self.monkeys.clone();
 
@@ -161,7 +161,7 @@ impl Puzzle {
             .map(|x| x.inspections)
             .collect::<Vec<usize>>();
         monkey_business.sort_by(|a, b| b.cmp(a));
-        monkey_business[0] * monkey_business[1]
+        (monkey_business[0] as u64) * (monkey_business[1] as u64)
     }
 }
 
diff --git a/2022/day15/day15.rs b/2022/day15/day15.rs
@@ -57,7 +57,7 @@ impl Puzzle {
     }
 
     // Solves part one
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u32 {
         let bx_min = self.beacons.iter().map(|x| x.0).min().unwrap() - self.max_d;
         let bx_max = self.beacons.iter().map(|x| x.0).max().unwrap() + self.max_d;
 
@@ -90,7 +90,7 @@ impl Puzzle {
     }
 
     // Solve part two
-    fn part2(&self) -> usize {
+    fn part2(&self) -> i64 {
         for y in 0..=self.field_size {
             // each sensor defines a zone where there is only one beacon
             // this zone is all points at a distance less than or equal to the Manhattan distance to its beacon
@@ -140,7 +140,7 @@ impl Puzzle {
 
             if column.len() > 1 {
                 let x = column.first().unwrap().1;
-                return (x * 4_000_000 + y) as usize;
+                return x * 4_000_000 + y;
             }
         }
 
diff --git a/2022/day20/day20.rs b/2022/day20/day20.rs
@@ -38,37 +38,37 @@ impl Puzzle {
     fn decrypt(&self, key: i64, rounds: usize) -> i64 {
         let mut q = VecDeque::new();
 
-        q.extend(self.numbers.iter().map(|x| (*x) * key).enumerate());
+        q.extend(self.numbers.iter().map(|x| (*x) * key).zip(0..));
 
-        let nb = self.numbers.len();
+        let nb = self.numbers.len() as i64;
 
         for _ in 0..rounds {
             for i in 0..nb {
-                let mut shift = (0usize, 0i64);
+                let mut shift = (0, 0);
 
                 while let Some(e) = q.pop_front() {
-                    if e.0 == i {
+                    if e.1 == i {
                         shift = e;
                         break;
                     }
                     q.push_back(e);
                 }
 
-                match shift.1 {
-                    o if o > 0 => q.rotate_left((o as usize) % (nb - 1)),
-                    o if o < 0 => q.rotate_right((-o as usize) % (nb - 1)),
+                match shift.0 {
+                    o if o > 0 => q.rotate_left(((o) % (nb - 1)) as usize),
+                    o if o < 0 => q.rotate_right(((-o) % (nb - 1)) as usize),
                     _ => (),
                 }
 
                 q.push_back(shift);
             }
         }
 
-        for (i, v) in q.iter().enumerate() {
-            if v.1 == 0 {
-                return q.get((i + 1000) % nb).unwrap().1
-                    + q.get((i + 2000) % nb).unwrap().1
-                    + q.get((i + 3000) % nb).unwrap().1;
+        for (v, i) in q.iter().zip(0..) {
+            if v.0 == 0 {
+                return q.get(((i + 1000) % nb) as usize).unwrap().0
+                    + q.get(((i + 2000) % nb) as usize).unwrap().0
+                    + q.get(((i + 3000) % nb) as usize).unwrap().0;
             }
         }
         0
diff --git a/2023/day11/day11.rs b/2023/day11/day11.rs
@@ -1,9 +1,9 @@
 //! [Day 11: Cosmic Expansion](https://adventofcode.com/2023/day/11)
 
 struct Puzzle {
-    galaxies: Vec<(usize, usize)>,
-    empty_rows: Vec<usize>,
-    empty_cols: Vec<usize>,
+    galaxies: Vec<(u64, u64)>,
+    empty_rows: Vec<u64>,
+    empty_cols: Vec<u64>,
 }
 
 impl Puzzle {
@@ -21,9 +21,9 @@ impl Puzzle {
 
         let mut grid = vec![];
 
-        for (y, line) in data.lines().enumerate() {
+        for (line, y) in data.lines().zip(0..) {
             let row: Vec<_> = line.chars().collect();
-            for (x, &c) in row.iter().enumerate() {
+            for (&c, x) in row.iter().zip(0..) {
                 if c == '#' {
                     self.galaxies.push((x, y));
                 }
@@ -38,12 +38,12 @@ impl Puzzle {
 
         for x in 0..grid[0].len() {
             if (0..grid.len()).all(|y| grid[y][x] == '.') {
-                self.empty_cols.push(x);
+                self.empty_cols.push(x as u64);
             }
         }
     }
 
-    fn solve(&self, expansion_factor: usize) -> usize {
+    fn solve(&self, expansion_factor: u64) -> u64 {
         let expansion_factor = expansion_factor - 1;
         let mut result = 0;
         for (i, &(x1, y1)) in self.galaxies.iter().enumerate() {
@@ -55,15 +55,15 @@ impl Puzzle {
                     .empty_cols
                     .iter()
                     .filter(|&&col| x1.min(x2) <= col && col <= x1.max(x2))
-                    .count()
+                    .count() as u64
                     * expansion_factor;
 
                 // expand empty spaces vertically
                 distance += self
                     .empty_rows
                     .iter()
                     .filter(|&&row| y1.min(y2) <= row && row <= y1.max(y2))
-                    .count()
+                    .count() as u64
                     * expansion_factor;
 
                 result += distance;
@@ -74,12 +74,12 @@ impl Puzzle {
     }
 
     /// Solve part one.
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u64 {
         self.solve(2)
     }
 
     /// Solve part two.
-    fn part2(&self) -> usize {
+    fn part2(&self) -> u64 {
         self.solve(1_000_000)
     }
 }
diff --git a/2023/day21/day21.rs b/2023/day21/day21.rs
@@ -63,7 +63,7 @@ impl Puzzle {
         self.garden[usize::try_from(i).unwrap()]
     }
 
-    fn count(&self, n: i32) -> usize {
+    fn count(&self, n: i32) -> u64 {
         // nota: still not really optimized, could probably memoize something
         let mut p = HashSet::new();
         p.insert((self.start_x, self.start_y));
@@ -116,10 +116,10 @@ impl Puzzle {
             p = np;
         }
 
-        p.len()
+        p.len() as u64
     }
 
-    fn big_count(&self, n: i32) -> usize {
+    fn big_count(&self, n: i32) -> u64 {
         // the step count curve is parabolic
         let (t, x0) = n.div_rem(&self.n);
 
@@ -138,18 +138,18 @@ impl Puzzle {
         let a = y2 - 2 * y1 + y0;
         let b = y1 - y0;
 
-        let t = usize::try_from(t).unwrap();
+        let t = u64::try_from(t).unwrap();
 
         a * t * (t - 1) / 2 + b * t + y0
     }
 
     /// Solve part one.
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u64 {
         self.count(64)
     }
 
     /// Solve part two.
-    fn part2(&self) -> usize {
+    fn part2(&self) -> u64 {
         self.big_count(26_501_365)
     }
 }
diff --git a/2023/day8/day8.rs b/2023/day8/day8.rs
@@ -3,7 +3,7 @@
 use num::Integer;
 use std::collections::HashMap;
 
-fn lcm(values: &Vec<usize>) -> usize {
+fn lcm(values: &Vec<u64>) -> u64 {
     let mut m = 1;
     for x in values {
         m = m.lcm(x);
@@ -44,7 +44,7 @@ impl Puzzle {
         }
     }
 
-    fn solve(&self, part1: bool) -> usize {
+    fn solve(&self, part1: bool) -> u64 {
         let start = u32::from_str_radix(if part1 { "AAA" } else { "A" }, 36).unwrap();
         let stop = u32::from_str_radix(if part1 { "ZZZ" } else { "Z" }, 36).unwrap();
         let mask = if part1 { 36 * 36 * 36 } else { 36 };
@@ -81,10 +81,10 @@ impl Puzzle {
                 *node = new_node;
 
                 if new_node % mask == stop {
-                    z.insert(i, n);
+                    z.insert(i, n as u64);
 
                     if z.len() == size {
-                        let z = z.values().copied().collect::<Vec<usize>>();
+                        let z: Vec<_> = z.values().copied().collect();
                         return lcm(&z);
                     }
                 }
@@ -93,12 +93,12 @@ impl Puzzle {
     }
 
     /// Solve part one.
-    fn part1(&self) -> usize {
+    fn part1(&self) -> u64 {
         self.solve(true)
     }
 
     /// Solve part two.
-    fn part2(&self) -> usize {
+    fn part2(&self) -> u64 {
         self.solve(false)
     }
 }
diff --git a/scripts/runall.py b/scripts/runall.py

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ impl Puzzle {`
`20`	`20`	`.collect();`
`21`	`21`	`}`
`22`	`22`
`23`		`- fn solve(&self, nb_cups: usize, nb_moves: usize) -> usize {`
	`23`	`+ fn solve(&self, nb_cups: usize, nb_moves: usize) -> u64 {`
`24`	`24`	`// cups are labeled from 1 to 9 (and from 10 to ncups), cup no. 0 is unused`
`25`	`25`
`26`	`26`	`let cups = \|i: usize\| {`
`@@ -68,26 +68,26 @@ impl Puzzle {`
`68`	`68`
`69`	`69`	`if nb_cups > self.cups.len() {`
`70`	`70`	`// answer for part 2`
`71`		`- (pos[pos[1]]) * (pos[1])`
	`71`	`+ (pos[pos[1]] as u64) * (pos[1] as u64)`
`72`	`72`	`} else {`
`73`	`73`	`// answer for part 1`
`74`	`74`	`let mut result = 0;`
`75`	`75`	`let mut cup = pos[1];`
`76`	`76`	`while cup != 1 {`
`77`		`- result = result * 10 + cup;`
	`77`	`+ result = result * 10 + cup as u64;`
`78`	`78`	`cup = pos[cup];`
`79`	`79`	`}`
`80`	`80`	`result`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/// Solve part one.`
`85`		`- fn part1(&self) -> usize {`
	`85`	`+ fn part1(&self) -> u64 {`
`86`	`86`	`self.solve(self.cups.len(), 100)`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`/// Solve part two.`
`90`		`- fn part2(&self) -> usize {`
	`90`	`+ fn part2(&self) -> u64 {`
`91`	`91`	`self.solve(1_000_000, 10_000_000)`
`92`	`92`	`}`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ void solve(const std::vector<Monkey> &monkeys_orig, int rounds)`
`91`	`91`	`{`
`92`	`92`	`return a.inspections > b.inspections;`
`93`	`93`	`});`
`94`		`- uint64_t monkey_business_level = monkeys[0].inspections * monkeys[1].inspections;`
	`94`	`+ uint64_t monkey_business_level = (uint64_t)monkeys[0].inspections * (uint64_t)monkeys[1].inspections;`
`95`	`95`
`96`	`96`	`std::cout << monkey_business_level << std::endl;`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,17 +112,17 @@ impl Puzzle {`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`/// Solves part one`
`115`		`- fn part1(&self) -> usize {`
	`115`	`+ fn part1(&self) -> u64 {`
`116`	`116`	`self.solve(20)`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`/// Solve part two`
`120`		`- fn part2(&self) -> usize {`
	`120`	`+ fn part2(&self) -> u64 {`
`121`	`121`	`self.solve(10000)`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`/// Solve the puzzle`
`125`		`- fn solve(&self, rounds: usize) -> usize {`
	`125`	`+ fn solve(&self, rounds: usize) -> u64 {`
`126`	`126`	`// we need to clone the monkeys array since we modify the starting item lists`
`127`	`127`	`let mut monkeys = self.monkeys.clone();`
`128`	`128`
`@@ -161,7 +161,7 @@ impl Puzzle {`
`161`	`161`	`.map(\|x\| x.inspections)`
`162`	`162`	`.collect::<Vec<usize>>();`
`163`	`163`	`monkey_business.sort_by(\|a, b\| b.cmp(a));`
`164`		`- monkey_business[0] * monkey_business[1]`
	`164`	`+ (monkey_business[0] as u64) * (monkey_business[1] as u64)`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ impl Puzzle {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`// Solves part one`
`60`		`- fn part1(&self) -> usize {`
	`60`	`+ fn part1(&self) -> u32 {`
`61`	`61`	`let bx_min = self.beacons.iter().map(\|x\| x.0).min().unwrap() - self.max_d;`
`62`	`62`	`let bx_max = self.beacons.iter().map(\|x\| x.0).max().unwrap() + self.max_d;`
`63`	`63`
`@@ -90,7 +90,7 @@ impl Puzzle {`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`// Solve part two`
`93`		`- fn part2(&self) -> usize {`
	`93`	`+ fn part2(&self) -> i64 {`
`94`	`94`	`for y in 0..=self.field_size {`
`95`	`95`	`// each sensor defines a zone where there is only one beacon`
`96`	`96`	`// this zone is all points at a distance less than or equal to the Manhattan distance to its beacon`
`@@ -140,7 +140,7 @@ impl Puzzle {`
`140`	`140`
`141`	`141`	`if column.len() > 1 {`
`142`	`142`	`let x = column.first().unwrap().1;`
`143`		`- return (x * 4_000_000 + y) as usize;`
	`143`	`+ return x * 4_000_000 + y;`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
Original file line number	Diff line number	Diff line change
`@@ -38,37 +38,37 @@ impl Puzzle {`
`38`	`38`	`fn decrypt(&self, key: i64, rounds: usize) -> i64 {`
`39`	`39`	`let mut q = VecDeque::new();`
`40`	`40`
`41`		`- q.extend(self.numbers.iter().map(\|x\| (x) key).enumerate());`
	`41`	`+ q.extend(self.numbers.iter().map(\|x\| (x) key).zip(0..));`
`42`	`42`
`43`		`- let nb = self.numbers.len();`
	`43`	`+ let nb = self.numbers.len() as i64;`
`44`	`44`
`45`	`45`	`for _ in 0..rounds {`
`46`	`46`	`for i in 0..nb {`
`47`		`- let mut shift = (0usize, 0i64);`
	`47`	`+ let mut shift = (0, 0);`
`48`	`48`
`49`	`49`	`while let Some(e) = q.pop_front() {`
`50`		`- if e.0 == i {`
	`50`	`+ if e.1 == i {`
`51`	`51`	`shift = e;`
`52`	`52`	`break;`
`53`	`53`	`}`
`54`	`54`	`q.push_back(e);`
`55`	`55`	`}`
`56`	`56`
`57`		`- match shift.1 {`
`58`		`- o if o > 0 => q.rotate_left((o as usize) % (nb - 1)),`
`59`		`- o if o < 0 => q.rotate_right((-o as usize) % (nb - 1)),`
	`57`	`+ match shift.0 {`
	`58`	`+ o if o > 0 => q.rotate_left(((o) % (nb - 1)) as usize),`
	`59`	`+ o if o < 0 => q.rotate_right(((-o) % (nb - 1)) as usize),`
`60`	`60`	`_ => (),`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`q.push_back(shift);`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`- for (i, v) in q.iter().enumerate() {`
`68`		`- if v.1 == 0 {`
`69`		`- return q.get((i + 1000) % nb).unwrap().1`
`70`		`- + q.get((i + 2000) % nb).unwrap().1`
`71`		`- + q.get((i + 3000) % nb).unwrap().1;`
	`67`	`+ for (v, i) in q.iter().zip(0..) {`
	`68`	`+ if v.0 == 0 {`
	`69`	`+ return q.get(((i + 1000) % nb) as usize).unwrap().0`
	`70`	`+ + q.get(((i + 2000) % nb) as usize).unwrap().0`
	`71`	`+ + q.get(((i + 3000) % nb) as usize).unwrap().0;`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`	`0`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ impl Puzzle {`
`63`	`63`	`self.garden[usize::try_from(i).unwrap()]`
`64`	`64`	`}`
`65`	`65`
`66`		`- fn count(&self, n: i32) -> usize {`
	`66`	`+ fn count(&self, n: i32) -> u64 {`
`67`	`67`	`// nota: still not really optimized, could probably memoize something`
`68`	`68`	`let mut p = HashSet::new();`
`69`	`69`	`p.insert((self.start_x, self.start_y));`
`@@ -116,10 +116,10 @@ impl Puzzle {`
`116`	`116`	`p = np;`
`117`	`117`	`}`
`118`	`118`
`119`		`- p.len()`
	`119`	`+ p.len() as u64`
`120`	`120`	`}`
`121`	`121`
`122`		`- fn big_count(&self, n: i32) -> usize {`
	`122`	`+ fn big_count(&self, n: i32) -> u64 {`
`123`	`123`	`// the step count curve is parabolic`
`124`	`124`	`let (t, x0) = n.div_rem(&self.n);`
`125`	`125`
`@@ -138,18 +138,18 @@ impl Puzzle {`
`138`	`138`	`let a = y2 - 2 * y1 + y0;`
`139`	`139`	`let b = y1 - y0;`
`140`	`140`
`141`		`- let t = usize::try_from(t).unwrap();`
	`141`	`+ let t = u64::try_from(t).unwrap();`
`142`	`142`
`143`	`143`	`a * t * (t - 1) / 2 + b * t + y0`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`/// Solve part one.`
`147`		`- fn part1(&self) -> usize {`
	`147`	`+ fn part1(&self) -> u64 {`
`148`	`148`	`self.count(64)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`/// Solve part two.`
`152`		`- fn part2(&self) -> usize {`
	`152`	`+ fn part2(&self) -> u64 {`
`153`	`153`	`self.big_count(26_501_365)`
`154`	`154`	`}`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`use num::Integer;`
`4`	`4`	`use std::collections::HashMap;`
`5`	`5`
`6`		`-fn lcm(values: &Vec<usize>) -> usize {`
	`6`	`+fn lcm(values: &Vec<u64>) -> u64 {`
`7`	`7`	`let mut m = 1;`
`8`	`8`	`for x in values {`
`9`	`9`	`m = m.lcm(x);`
`@@ -44,7 +44,7 @@ impl Puzzle {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- fn solve(&self, part1: bool) -> usize {`
	`47`	`+ fn solve(&self, part1: bool) -> u64 {`
`48`	`48`	`let start = u32::from_str_radix(if part1 { "AAA" } else { "A" }, 36).unwrap();`
`49`	`49`	`let stop = u32::from_str_radix(if part1 { "ZZZ" } else { "Z" }, 36).unwrap();`
`50`	`50`	`let mask = if part1 { 36 * 36 * 36 } else { 36 };`
`@@ -81,10 +81,10 @@ impl Puzzle {`
`81`	`81`	`*node = new_node;`
`82`	`82`
`83`	`83`	`if new_node % mask == stop {`
`84`		`- z.insert(i, n);`
	`84`	`+ z.insert(i, n as u64);`
`85`	`85`
`86`	`86`	`if z.len() == size {`
`87`		`- let z = z.values().copied().collect::<Vec<usize>>();`
	`87`	`+ let z: Vec<_> = z.values().copied().collect();`
`88`	`88`	`return lcm(&z);`
`89`	`89`	`}`
`90`	`90`	`}`
`@@ -93,12 +93,12 @@ impl Puzzle {`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`/// Solve part one.`
`96`		`- fn part1(&self) -> usize {`
	`96`	`+ fn part1(&self) -> u64 {`
`97`	`97`	`self.solve(true)`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`/// Solve part two.`
`101`		`- fn part2(&self) -> usize {`
	`101`	`+ fn part2(&self) -> u64 {`
`102`	`102`	`self.solve(false)`
`103`	`103`	`}`
`104`	`104`	`}`