remove print

2024
old stuff
2025-09-09 00:10:40 +00:00 · 2024-12-08 21:37:22 +01:00 · 2024-12-08 21:36:04 +01:00 · 2024-12-08 21:34:32 +01:00 · 2023-12-04 21:08:43 +01:00 · 2023-12-02 00:28:26 +01:00
47 changed files with 2072 additions and 128 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,18 @@
 node_modules
 *.txt
 .env*
+
+
+# Added by cargo
+/target
+
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
--- a/.nvmrc
+++ b/.nvmrc
@@ -0,0 +1 @@
+v21
--- a/.python-version
+++ b/.python-version
@@ -0,0 +1 @@
+3.12
--- a/2019/3/README.md
+++ b/2019/3/README.md
@@ -0,0 +1,11 @@
+# 3
+
+Description
+
+<details>
+  <summary>Solutions</summary>
+  <ol>
+    <li>1</li>
+    <li>2</li>
+  </ol>
+</details>
--- a/2019/3/python/main.py
+++ b/2019/3/python/main.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+
+from os.path import join, dirname
+
+# Day 3
+
+# Common
+
+
+def read_input(filename):
+    data = join(dirname(__file__), '..', filename)
+    with open(data) as f:
+        return f.read().strip()
+
+
+test = read_input('test.txt')
+data = read_input('input.txt')
+
+# Running
+
+Point = tuple[int, int]
+
+class Line:
+    def __init__(self, start:Point, end: Point) -> None:
+        pass
+
+class Wire:
+    def __init__(self, points: list[Point]) -> None:
+        self.points = points
+
+    def __iter__(self):
+        self.i = 0
+        self.max = len(self.points) - 1
+        return self
+
+    def __next__(self):
+        if self.i >= self.max:
+            raise StopIteration
+        value = (self.points[self.i], self.points[self.i +1])
+        self.i += 1
+        return value
+
+    def __str__(self) -> str:
+        return ', '.join([f'({x}, {y})' for x, y in self.points])
+
+    def find_intersections(self, other: Line) -> list[Point]:
+        matches: list[Point] = []
+        for a in self:
+            for b in other:
+                if a[0][0] < b[0] 
+                # if a[0] == b[0] and a[1] == b[1]:
+                #     matches.append(a[0])
+        return matches
+
+    @staticmethod
+    def parse(raw: str):
+        commands = raw.split(',')
+        current: Point = (0, 0)
+        points: list[Point] = [current]
+        for command in commands:
+            direction = command[0]
+            length = int(command[1:])
+            match direction:
+                case 'L':
+                    current = (current[0] - length, current[1])
+                case 'R':
+                    current = (current[0] + length, current[1])
+                case 'U':
+                    current = (current[0], current[1] + length)
+                case 'D':
+                    current = (current[0], current[1] - length)
+            points.append(current)
+        return Wire(points)
+
+
+class Panel():
+    def __init__(self, wires: list[Wire]) -> None:
+        self.wires = wires
+
+    def find_closes(self):
+        matches = self.wires[0].find_intersections(self.wires[1].line)
+        distances = [abs(x)+abs(y) for x, y in matches]
+        return min(distances)
+
+    @staticmethod
+    def parse(raw: str):
+        return Panel(wires=[Wire.parse(line) for line in raw.splitlines()])
+
+
+p = Panel.parse(test)
+# print([str(w) for w in p.wires])
+for wire in p.wires:
+    print(wire)
+    for line in wire:
+        print(line)
+# print(p.find_closes())
--- a/2022/01/rust/main.rs
+++ b/2022/01/rust/main.rs
@@ -0,0 +1,53 @@
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::{black_box, Bencher};
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| black_box(part_a(INPUT)));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| black_box(part_b(INPUT)));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+fn part_a(input: &str) {
+    let result: u32 = input
+        .trim()
+        .split("\n\n")
+        .map(|x| x.lines().map(|x| x.parse::<u32>().unwrap()).sum())
+        .max()
+        .unwrap();
+    println!("{}", result);
+}
+
+fn part_b(input: &str) {
+    let mut result = input
+        .trim()
+        .split("\n\n")
+        .map(|x| x.lines().map(|x| x.parse::<u32>().unwrap()).sum::<u32>())
+        .collect::<Vec<u32>>();
+    result.sort_unstable();
+    let total = result.into_iter().rev().take(3).sum::<u32>();
+    println!("{}", total);
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    part_b(INPUT);
+}
--- a/2022/02/rust/main.rs
+++ b/2022/02/rust/main.rs
@@ -0,0 +1,129 @@
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_a_old(b: &mut Bencher) {
+        b.iter(|| part_a_old(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const TEST: &str = include_str!("../test.txt");
+const INPUT: &str = include_str!("../input.txt");
+
+#[derive(Debug, Clone, Copy)]
+enum Type {
+    Rock = 1,
+    Paper = 2,
+    Scissor = 3,
+}
+
+#[derive(Debug)]
+struct Game(Type, Type);
+
+impl Game {
+    fn score(&self) -> u32 {
+        let mut total = self.0 as u32;
+        // Result will be: 0=draw 1=win 2=loss
+        let result = (self.0 as i8 - self.1 as i8).rem_euclid(3) as u8;
+        total += match result {
+            1 => 6,
+            0 => 3,
+            _ => 0,
+        };
+        total
+    }
+}
+
+fn part_a_old(input: &str) {
+    let result = input
+        .trim()
+        .lines()
+        .map(|line| {
+            let opponent: Type = match line.chars().nth(0).unwrap() {
+                'A' => Type::Rock,
+                'B' => Type::Paper,
+                'C' => Type::Scissor,
+                _ => panic!("unkown input"),
+            };
+            let me = match line.chars().nth(2).unwrap() {
+                'X' => Type::Rock,
+                'Y' => Type::Paper,
+                'Z' => Type::Scissor,
+                _ => panic!("unkown input"),
+            };
+            let g: Game = Game(me, opponent);
+            g.score()
+        })
+        .sum::<u32>();
+    println!("A: {:?}", result);
+}
+
+fn part_a(input: &str) {
+    let result = input
+        .trim()
+        .lines()
+        .map(|line| {
+            let bytes = line.as_bytes();
+            let opponent = bytes[0] - b'A';
+            let me: u8 = bytes[2] - b'X';
+
+            let total = me + 1;
+            // Result will be: 0=draw 1=win 2=loss
+            let result = (me as i8 - opponent as i8).rem_euclid(3);
+            let score = match result {
+                1 => 6,
+                0 => 3,
+                _ => 0,
+            };
+            (total + score) as u16
+        })
+        .sum::<u16>();
+    println!("{}", result);
+}
+
+fn part_b(input: &str) {
+    let result = input
+        .trim()
+        .lines()
+        .map(|line| {
+            let bytes = line.as_bytes();
+            let opponent = bytes[0] - 'A' as u8;
+            let result: u8 = bytes[2] - 'X' as u8;
+
+            let total: u8 = match result {
+                1 => 3,
+                2 => 6,
+                _ => 0,
+            };
+            let me = (opponent + result + 2).rem_euclid(3);
+            (total + me + 1) as u16
+        })
+        .sum::<u16>();
+    println!("{}", result);
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    part_b(INPUT);
+}
--- a/2023/01/README.md
+++ b/2023/01/README.md
@@ -0,0 +1,11 @@
+# 01
+
+- First, in the B, was replacing all letters, which did work for the test data, but not the input. Then I just actually searched fof the first and last occurrence.
+
+<details>
+  <summary>Solutions</summary>
+  <ol>
+    <li>54605</li>
+    <li>55429</li>
+  </ol>
+</details>
--- a/2023/01/rust/main.rs
+++ b/2023/01/rust/main.rs
@@ -0,0 +1,103 @@
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+fn part_a(input: &str) {
+    let result = input
+        .trim()
+        .split("\n")
+        .map(|line| {
+            let mut first: u16 = 0;
+            for char in line.chars() {
+                if first != 0 {
+                    break;
+                }
+                match char {
+                    '1' => first = 1,
+                    '2' => first = 2,
+                    '3' => first = 3,
+                    '4' => first = 4,
+                    '5' => first = 5,
+                    '6' => first = 6,
+                    '7' => first = 7,
+                    '8' => first = 8,
+                    '9' => first = 9,
+                    _ => continue,
+                }
+            }
+            let mut last: u16 = 0;
+            for char in line.chars().rev() {
+                if last != 0 {
+                    break;
+                }
+                match char {
+                    '1' => last = 1,
+                    '2' => last = 2,
+                    '3' => last = 3,
+                    '4' => last = 4,
+                    '5' => last = 5,
+                    '6' => last = 6,
+                    '7' => last = 7,
+                    '8' => last = 8,
+                    '9' => last = 9,
+                    _ => continue,
+                }
+            }
+            return first * 10 + last;
+        })
+        .sum::<u16>();
+    println!("{}", result);
+}
+
+fn part_b(input: &str) {
+    let result = input
+        .trim()
+        .split("\n")
+        .map(|line| {
+            let mut first: usize = 0;
+            let nums = [
+                "1", "2", "3", "4", "5", "6", "7", "8", "9", "one", "two", "three", "four", "five",
+                "six", "seven", "eight", "nine",
+            ];
+            for (i, s) in nums.iter().enumerate() {
+                if line.starts_with(s) {
+                    first = if i < 9 { i + 1 } else { i - 8 };
+                    break;
+                }
+                line.split_at(mid)
+            }
+            let mut last = 0 as usize;
+            return first * 10 + last;
+        })
+        .sum::<usize>();
+    println!("{}", result);
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    // part_b(INPUT);
+}
--- a/2023/01/typescript/main.ts
+++ b/2023/01/typescript/main.ts
@@ -0,0 +1,60 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+// SETUP
+const INPUT = fs.readFileSync(path.join(import.meta.dir, '../input.txt'), 'utf-8').trim()
+const TEST = fs.readFileSync(path.join(import.meta.dir, '../test.txt'), 'utf-8').trim()
+
+// TASK
+
+function partA(input: string) {
+  const total = input
+    .split('\n')
+    .map((line) => {
+      const digits = line.split('').filter((c) => /\d/.test(c))
+      return parseInt(digits[0]! + digits[digits.length - 1])
+    })
+    .reduce((acc, cur) => acc + cur, 0)
+  console.log(total)
+}
+
+function partB(input: string) {
+  const names = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
+  const total = input
+    .split('\n')
+    .map((line) => {
+      let first = 0
+      let last = 0
+      root: for (let i = 0; i < line.length; i++) {
+        for (const [num, name] of names.entries()) {
+          const asString = (num + 1).toString()
+          if (line[i] === asString || line.slice(i).startsWith(name)) {
+            first = num + 1
+            break root
+          }
+        }
+      }
+
+      root: for (let i = line.length; i >= 0; i--) {
+        for (const [num, name] of names.entries()) {
+          const asString = (num + 1).toString()
+          if (line[i] === asString || line.slice(i).startsWith(name)) {
+            last = num + 1
+            break root
+          }
+        }
+      }
+
+      return last + 10 * first
+    })
+    .reduce((acc, cur) => acc + cur, 0)
+  console.log(total)
+}
+
+console.log('Part A:')
+partA(TEST)
+partA(INPUT)
+
+console.log('Part B:')
+partB(TEST)
+partB(INPUT)
--- a/2023/02/README.md
+++ b/2023/02/README.md
@@ -0,0 +1,11 @@
+# 02
+
+Learned about callbacks in rust.
+
+<details>
+  <summary>Solutions</summary>
+  <ol>
+    <li>2348</li>
+    <li>76008</li>
+  </ol>
+</details>
--- a/2023/02/rust/main.rs
+++ b/2023/02/rust/main.rs
@@ -0,0 +1,106 @@
+#![feature(test)]
+
+use std::cmp;
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+#[derive(Debug)]
+struct Round {
+    red: usize,
+    blue: usize,
+    green: usize,
+}
+
+fn max_for_game(s: &str, calc: impl Fn(Round) -> usize) -> usize {
+    let max = s
+        .split(";")
+        .map(|round| {
+            // Max count
+            let mut r = Round {
+                blue: 0,
+                green: 0,
+                red: 0,
+            };
+            for pick in round.split(",") {
+                let parts: Vec<&str> = pick.trim().split(" ").collect();
+                let num: usize = parts[0].parse().unwrap();
+                match parts[1] {
+                    "blue" => r.blue = num,
+                    "green" => r.green = num,
+                    "red" => r.red = num,
+                    _ => panic!("Invalid color {}", parts[1]),
+                }
+            }
+            r
+        })
+        .reduce(|a, b| Round {
+            red: cmp::max(a.red, b.red),
+            blue: (cmp::max(a.blue, b.blue)),
+            green: (cmp::max(a.green, b.green)),
+        })
+        .unwrap();
+    calc(max)
+}
+
+fn parse_game_b(s: &str) -> usize {
+    let splitted: Vec<&str> = s.split(":").collect();
+    max_for_game(splitted[1], |x| x.blue * x.green * x.red)
+}
+
+fn part_a(input: &str) {
+    let result: usize = input
+        .trim()
+        .split("\n")
+        .map(|line| {
+            let splitted: Vec<&str> = line.split(":").collect();
+            max_for_game(splitted[1], |r| {
+                if r.red <= 12 && r.green <= 13 && r.blue <= 14 {
+                    splitted[0].split_at(5).1.parse().unwrap()
+                } else {
+                    0
+                }
+            })
+        })
+        .sum();
+    println!("{result}");
+}
+
+fn part_b(input: &str) {
+    let result: usize = input
+        .trim()
+        .split("\n")
+        .map(|line| {
+            return parse_game_b(line);
+        })
+        .sum();
+    println!("{result}");
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    part_b(INPUT);
+}
--- a/2023/03/README.md
+++ b/2023/03/README.md
@@ -0,0 +1,11 @@
+# 03
+
+Description
+
+<details>
+  <summary>Solutions</summary>
+  <ol>
+    <li>1</li>
+    <li>2</li>
+  </ol>
+</details>
--- a/2023/03/rust/main.rs
+++ b/2023/03/rust/main.rs
@@ -0,0 +1,64 @@
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+struct Point {
+    x: usize,
+    y: usize,
+}
+
+fn part_a(input: &str) {
+    let result = input.trim();
+
+    let lines = result.split("\n").collect::<Vec<&str>>();
+
+    let mut symbols: Vec<Vec<usize>> = Vec::new();
+    for _ in [0..lines.len()] {
+        symbols.push(vec![0; 0]);
+    }
+
+    for (y, line) in result.split("\n").enumerate() {
+        for (x, char) in line.chars().enumerate() {
+            match char {
+                '*' | '&' | '+' | '#' | '$' => symbols[y].push(x),
+                _ => {}
+            }
+        }
+    }
+
+    println!("{:?}", symbols);
+}
+
+fn part_b(input: &str) {
+    let result = input.trim();
+    println!("{}", result);
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    // part_a(INPUT);
+
+    println!("\nPart B:");
+    // part_b(TEST);
+    // part_b(INPUT);
+}
--- a/2023/04/README.md
+++ b/2023/04/README.md
@@ -0,0 +1,11 @@
+# 04
+
+Description
+
+<details>
+  <summary>Solutions</summary>
+  <ol>
+    <li>1</li>
+    <li>2</li>
+  </ol>
+</details>
--- a/2023/04/rust/main.rs
+++ b/2023/04/rust/main.rs
@@ -0,0 +1,127 @@
+#![feature(test)]
+
+use std::collections::HashMap;
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+fn get_matches_per_card(input: &str) -> Vec<usize> {
+    input
+        .trim()
+        .split("\n")
+        .map(|line| {
+            let splitted: Vec<&str> = line.split(":").collect();
+            let body = splitted[1]
+                .split("|")
+                .map(|part| {
+                    let mut numbers = part
+                        .trim()
+                        .split(" ")
+                        .filter(|x| x.len() > 0)
+                        .map(|s| s.parse::<usize>().expect("not a number"))
+                        .collect::<Vec<usize>>();
+                    numbers.sort();
+                    numbers
+                })
+                .collect::<Vec<Vec<usize>>>();
+
+            let numbers = &body[0];
+            let winning = &body[1];
+
+            let mut matches = 0_usize;
+            for number in numbers {
+                match winning.binary_search(number) {
+                    Err(_) => {}
+                    Ok(_) => matches += 1,
+                }
+            }
+
+            matches
+        })
+        .collect()
+}
+
+fn part_a(input: &str) {
+    let matches = get_matches_per_card(input);
+    let total: usize = matches
+        .iter()
+        .map(|matches| {
+            if *matches > 0 {
+                2_usize.pow(*matches as u32 - 1)
+            } else {
+                0
+            }
+        })
+        .sum();
+
+    println!("{total}");
+}
+
+fn add_points(matches: &Vec<usize>, cache: &mut HashMap<usize, usize>, number: usize) -> usize {
+    let cached = cache.get(&number);
+    match cached {
+        Some(x) => *x,
+        None => {
+            let m = matches[number];
+            if m == 0 {
+                return 0;
+            }
+            let mut total = 0;
+            for n in number + 1..(number + m) {
+                total += add_points(matches, cache, n);
+            }
+            cache.insert(number, total);
+            total
+        }
+    }
+}
+
+fn part_b(input: &str) {
+    let matches = get_matches_per_card(input);
+    let mut cache: HashMap<usize, usize> = HashMap::new();
+    let mut scores = vec![0, matches.len()];
+    let mut total: usize = 0;
+    for m in matches {
+        // total += add_points(&matches, &mut cache, m);
+    }
+    // let total: usize = matches
+    //     .iter()
+    //     .map(|matches| {
+    //         if *matches > 0 {
+    //             2_usize.pow(matches - 1)
+    //         } else {
+    //             0
+    //         }
+    //     })
+    //     .sum();
+
+    // println!("{total}");
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    // part_b(INPUT);
+}
--- a/2024/01/main.py
+++ b/2024/01/main.py
@@ -0,0 +1,45 @@
+from typing import List
+
+
+def calc(raw: str) -> int:
+    left: List[int] = []
+    right: List[int] = []
+    for line in raw.splitlines():
+        [left_raw, right_raw] = line.split("   ")
+        left.append(int(left_raw))
+        right.append(int(right_raw))
+
+    left.sort()
+    right.sort()
+
+    # Part 1
+    part1 = 0
+    for i in range(len(left)):
+        diff = abs(left[i] - right[i])
+        part1 += diff
+
+    # Part 2
+    part2 = 0
+    counts = {}
+    for x in right:
+        if x in counts:
+            counts[x] += 1
+        else:
+            counts[x] = 1
+
+    for x in left:
+        if x in counts:
+            part2 += x * counts[x]
+
+    return (part1, part2)
+
+
+# Test
+with open("./2024/01/test.txt", "r") as f:
+    result = calc(f.read().strip())
+    print(result)
+
+# Input
+with open("./2024/01/input.txt", "r") as f:
+    result = calc(f.read().strip())
+    print(result)
--- a/2024/02/findings.md
+++ b/2024/02/findings.md
@@ -0,0 +1,26 @@
+# Day 2
+
+In part two i got stuck because I wanted to be smart. Don't be smart, unless you really are, unlike me.
+
+So [the challenge](https://adventofcode.com/2024/day/2) was to allow one possible error in a _report_
+
+Given the level `1 3 2 4 5`, which fails because the 2 decreases, instead of increasing, i though it would be neat to only try removing one of each numbers.
+In this case either the `3` or the `2`. I did not want to brute force through the array. What was i missing?
+
+I then quickly found out, as the brute force variant is trivial to implement (on error, just retry every combination with one missing, breaking at the first _safe_ combination). The output was correct with the brute force variant, but my "smart™️" solution was off by very little, so what were the few edge cases?
+
+These 4 are safe with the _Problem Dampener_, but were not detected by my "smart™️" algorithm.
+
+```
+[55, 52, 53, 54, 56, 57]
+[17, 15, 16, 19, 20, 23, 25]
+[56, 57, 56, 55, 54, 51, 50, 49]
+[81, 84, 81, 80, 77, 75, 72, 69]
+```
+
+Why? well the issue was, that the error always occurred when the wrong number was the first one, giving a bad prediction for the "direction", basically whether the numbers would increase or decrease. Since the issue was always the third number with index `2`, removing either the second or third element was not enough, as the root cause was that the first items was already wrong, but only detected to late.
+
+## Possible solutions
+
+In my head, another way to visualise it, was to think in differences, where the first element would be always 0, and the next ones the diff to the previous one. In that case we could check for steady increase/decrease by making sure that all the subsequent numbers are all positive or negative.
+Basically like a drawn line, with one outlier.
--- a/2024/02/main.py
+++ b/2024/02/main.py
@@ -0,0 +1,80 @@
+def is_safe_1(numbers, tolerance=0) -> bool:
+    if len(numbers) < 2:
+        return True
+
+    down = numbers[0] > numbers[1]
+    cur = numbers[0]
+    for i in range(1, len(numbers)):
+        x = numbers[i]
+        diff = x - cur
+        if down:
+            diff *= -1
+        if 3 < diff or diff < 1:
+            if tolerance == 0:
+                return False
+            else:
+                found = set()
+                for j in range(len(numbers)):
+                    tmp = numbers[:]
+                    del tmp[j]
+                    if is_safe_1(tmp, tolerance - 1):
+                        found.add(tuple(tmp))
+                        # print("adding", tuple(tmp))
+                        return True
+                        break
+                else:
+                    # return False
+                    pass
+
+                # print(len(found))
+
+                first_removed = numbers[:]
+                del first_removed[i - 1]
+                if is_safe_1(first_removed, tolerance - 1):
+                    return True
+                second_removed = numbers[:]
+                del second_removed[i]
+                if is_safe_1(second_removed, tolerance - 1):
+                    return True
+
+                if len(found) > 0:
+                    print(numbers, i, x)
+                    print(first_removed, second_removed)
+                    print(numbers, found)
+                return False
+        cur = x
+    return True
+
+
+def is_safe_2(numbers, tolerance=0):
+    # Convert to differences
+    diffs = [0]  # First element is zero, as there is no predecessor
+    for i in range(1, len(numbers)):
+        diffs.append(numbers[i] - numbers[i - 1])
+    print(numbers, diffs)
+
+
+def solve(raw: str) -> int:
+    # Part 1
+    part1 = 0
+    part2 = 0
+
+    for line in raw.splitlines():
+        numbers = [int(x) for x in line.split(" ")]
+        if is_safe_2(numbers):
+            part1 += 1
+        if is_safe_2(numbers, 1):
+            part2 += 1
+
+    return (part1, part2)
+
+
+# Test
+with open("./2024/02/test.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
+
+# Input
+# with open("./2024/02/input.txt", "r") as f:
+#     result = solve(f.read().strip())
+#     print(result)
--- a/2024/03/findings.md
+++ b/2024/03/findings.md
@@ -0,0 +1,10 @@
+# Day 3
+
+Of course 1 min of regex freestyle (`mul\(\d+,\d+\)`) and it would have been done, i wanted to do it on my own.
+NVM did it with Regex xD
+
+Part 2 was fun, I basically computed an array of the `do()` and `don't()` index and simply looked up which one was further up.
+
+## Other ways
+
+I think a way more efficient way to go about it would to take more of a scan approach, where we keep track of the enabled/disabled status and parse as we go.
--- a/2024/03/main.py
+++ b/2024/03/main.py
@@ -0,0 +1,49 @@
+import re
+
+re_mul = re.compile(r"mul\(\d+,\d+\)")
+re_enable = re.compile(r"do\(\)")
+re_disable = re.compile(r"don't\(\)")
+
+
+def solve(raw: str) -> int:
+    # Part 1
+    part1 = 0
+    part2 = 0
+
+    enable = [m.end() for m in re_enable.finditer(raw)]
+    disable = [m.end() for m in re_disable.finditer(raw)]
+    for match in re_mul.finditer(raw):
+        # Part 1
+        [left, right] = match.group()[4:-1].split(",")
+        result = int(left) * int(right)
+        part1 += result
+
+        # Part 2
+        s = match.start()
+        last_enable = 0
+        for x in enable:
+            if x > s:
+                break
+            last_enable = x
+        last_disable = 0
+        for x in disable:
+            if x > s:
+                break
+            last_disable = x
+
+        disabled = last_disable != 0 and last_disable > last_enable
+        if disabled:
+            continue
+        part2 += result
+    return (part1, part2)
+
+
+# Test
+with open("./2024/03/test.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
+
+# Input
+with open("./2024/03/input.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
--- a/2024/04/findings.md
+++ b/2024/04/findings.md
@@ -0,0 +1,11 @@
+# Day 4
+
+## Part 1
+
+I keep not learning. RTFM.
+
+I started happily recursing into snakes of _XMAS_ letters, only to realise that only linear words are requested. Simple loop then.
+
+## Part 2
+
+Also quite easy. At first i messed up the cross, as i was checking for every angle, not only 45. And i had an error in the inverse of the direction of the cross, but nothing to hard.
--- a/2024/04/main.py
+++ b/2024/04/main.py
@@ -0,0 +1,130 @@
+from typing import List, Union, Tuple
+
+Point = Tuple[int]
+Path = Tuple[Point]
+Paths = [Path]
+
+ALL_DIRECTIONS = (
+    (1, 1),
+    (1, 0),
+    (1, -1),
+    (0, 1),
+    (0, -1),
+    (-1, 1),
+    (-1, 0),
+    (-1, -1),
+)
+
+LETTER_MAP = {"X": 0, "M": 1, "A": 2, "S": 3}
+
+
+class Board:
+    rows: List[List[int]]
+
+    def __init__(self, rows: List[List[int]]):
+        self.rows = rows
+        self.max_y = len(self.rows)
+        self.max_x = len(self.rows[0])
+
+    def get(self, x: int, y: int) -> Union[None, int]:
+        if x < 0 or y < 0:
+            return None
+        if x >= self.max_x or y >= self.max_y:
+            return None
+        return self.rows[y][x]
+
+    # def get_neighbours(self, x: int, y: int, target: int) -> List[Point]:
+    #     n = []
+    #     for dx in range(x - 1, x + 2):
+    #         for dy in range(y - 1, y + 2):
+    #             if self.get(dx, dy) == target:
+    #                 n.append((dx, dy))
+    #     return n
+
+    @staticmethod
+    def parse(raw: str):
+        rows = [[LETTER_MAP[letter] for letter in line] for line in raw.splitlines()]
+        return Board(rows)
+
+
+# def find_maze(b: Board, path: Path, next_char: int) -> Paths:
+#     x, y = path[-1]
+#     print(f"Find {x} {y} n={next_char}")
+#     paths: Paths = []
+#     neighbours = b.get_neighbours(x, y, next_char)
+
+#     # Found last letter
+#     if next_char == 3:
+#         return [path + (n,) for n in neighbours]
+
+#     # Recurse
+#     for n in neighbours:
+#         p = path + (n,)
+#         sub_paths = find(b, p, next_char + 1)
+#         if len(sub_paths):
+#             paths = paths + sub_paths
+
+#     return paths
+
+
+def find_line(b: Board, point: Point, direction: Point) -> Union[Path, None]:
+    x, y = point
+    dx, dy = direction
+    path: Path = point
+    for i in range(1, 4):
+        px = x + (dx * i)
+        py = y + (dy * i)
+        if b.get(px, py) != i:
+            return None
+        path = path + ((x, y),)
+    return path
+
+
+def find_x(b: Board, point: Point) -> bool:
+    x, y = point
+    for dx, dy in ALL_DIRECTIONS:
+        # Check if is "M", then the opposite for "S" and the the perpendicular
+        if b.get(x + dx, y + dy) == 1:
+            if b.get(x - dx, y - dy) == 3:
+                # Found first "MAS", check perpendicular
+                p_dx = -dy
+                p_dy = dx
+                p_a = b.get(x + p_dx, y + p_dy)
+                p_b = b.get(x - p_dx, y - p_dy)
+                if (p_a == 1 and p_b == 3) or (p_a == 3 and p_b == 1):
+                    return True
+    return False
+
+
+def solve(raw: str) -> int:
+    # Part 1
+    part1 = []
+    part2 = 0
+
+    b = Board.parse(raw)
+
+    for x in range(b.max_x):
+        for y in range(b.max_y):
+            p = b.get(x, y)
+            if p == 0:
+                for direction in ALL_DIRECTIONS:
+                    found = find_line(b, (x, y), direction)
+                    if found:
+                        part1.append(found)
+
+            if p == 2:
+                if find_x(b, (x, y)):
+                    part2 += 1
+
+    return (len(part1), part2)
+
+
+# Test
+with open("./2024/04/test.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
+
+# Input
+with open("./2024/04/input.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
--- a/2024/05/day_5_dag_reduced.svg
+++ b/2024/05/day_5_dag_reduced.svg
--- a/2024/05/day_5_dag_test.svg
+++ b/2024/05/day_5_dag_test.svg
--- a/2024/05/findings.md
+++ b/2024/05/findings.md
@@ -0,0 +1,20 @@
+# Day 5
+
+# Part 1
+
+What a joy! First day where a bit of Computer Science might actually help.
+So to me this looks like a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph), since if there has to be an order, cycles cannot be allowed. Otherwise the problem could not be solved.
+
+For not I just hope that it's one cohesive DAG, and not 2 or more. Technically there is a possibility that more than one, disjoined DAGs are defined by the rules. If this occurs, we'll see.
+
+![DAG Image](./day_5_dag_test.svg)
+
+We can see that there in this case there is one "start" and one "end". In this case `97` is the start and `13` the end. Again, there might be more than one "start" or "end".
+
+My idea is to precompile an order so that `97=0` and `13=7` so that we then just map the numbers to their ascending number and check if the array is already sorted. Why? My assumption is that you do the work upfront and then it's efficient to check for each input.
+
+The start and ends are easy, what about the _middle_ nodes? We can do a so called transitive reduction, simplifying the graph. Basically, if we know that `97` needs to be before `61` and `13` and at the same time `61` needs to be before `13`, we can delete the `97` before `13` link, as it's already specified going over `61`. Basically we eliminate all the "shortcuts". This gives us a nice line in this case.
+
+![reduced DAG](./day_5_dag_reduced.svg)
+
+_no code has been written until now, this might go terribly wrong 💩_
--- a/2024/05/main.py
+++ b/2024/05/main.py
@@ -0,0 +1,95 @@
+from typing import List, Union, Tuple, Set
+from dataclasses import dataclass
+import networkx as nx
+import matplotlib.pyplot as plt
+
+
+@dataclass
+class Node:
+    id: int
+    links: List
+
+
+@dataclass
+class Manual:
+    rules: Tuple[int]
+    updates: Tuple[int]
+
+    def check_update(self, update: Tuple[int]) -> bool:
+        cur = 0
+        for n in update:
+            if n not in self.order:
+                continue
+            m = self.order[n]
+            if m < cur:
+                return False
+            cur = m
+        return True
+
+    def check(self):
+        total = 0
+        for update in self.updates:
+            valid = self.check_update(update)
+            if valid:
+                total += update[len(update) // 2]
+        return total
+
+    def build_rules(self):
+        unique: Set[int] = set()
+        for rule in self.rules:
+            unique.add(rule[0])
+            unique.add(rule[1])
+        nodes = {n: Node(id=n, links=[]) for n in unique}
+        for start, end in self.rules:
+            nodes[start].links.append(end)
+
+        # Test
+        G = nx.DiGraph()
+        for rule in self.rules:
+            G.add_edge(*rule)
+        print(G.number_of_nodes())
+
+        TR = nx.transitive_reduction(G)
+        subax1 = plt.subplot(121)
+        nx.draw(TR, with_labels=True, font_weight="bold")
+        plt.show()
+
+        sorted = list(nx.topological_sort(G))
+        print(sorted)
+
+        # Topological sorting
+        # https://cs.stackexchange.com/a/29133
+        order = {n: i for i, n in enumerate(sorted)}
+        self.order = order
+
+    @staticmethod
+    def parse(raw: str):
+        rules_raw, updates_raw = raw.strip().split("\n\n")
+        rules = [tuple((map(int, line.split("|")))) for line in rules_raw.splitlines()]
+        updates = [
+            tuple(map(int, line.split(","))) for line in updates_raw.splitlines()
+        ]
+        return Manual(rules, updates)
+
+
+def solve(raw: str) -> int:
+    # Part 1
+    part1 = 0
+    part2 = 0
+
+    m = Manual.parse(raw)
+    m.build_rules()
+    part1 = m.check()
+
+    return (part1, part2)
+
+
+# Test
+with open("./2024/05/test.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
+
+# Input
+with open("./2024/05/input.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
--- a/2024/06/findings.md
+++ b/2024/06/findings.md
@@ -0,0 +1,20 @@
+# Day 5
+
+# Part 1
+
+What a joy! First day where a bit of Computer Science might actually help.
+So to me this looks like a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph), since if there has to be an order, cycles cannot be allowed. Otherwise the problem could not be solved.
+
+For not I just hope that it's one cohesive DAG, and not 2 or more. Technically there is a possibility that more than one, disjoined DAGs are defined by the rules. If this occurs, we'll see.
+
+![DAG Image](./day_5_dag_test.svg)
+
+We can see that there in this case there is one "start" and one "end". In this case `97` is the start and `13` the end. Again, there might be more than one "start" or "end".
+
+My idea is to precompile an order so that `97=0` and `13=7` so that we then just map the numbers to their ascending number and check if the array is already sorted. Why? My assumption is that you do the work upfront and then it's efficient to check for each input.
+
+The start and ends are easy, what about the _middle_ nodes? We can do a so called transitive reduction, simplifying the graph. Basically, if we know that `97` needs to be before `61` and `13` and at the same time `61` needs to be before `13`, we can delete the `97` before `13` link, as it's already specified going over `61`. Basically we eliminate all the "shortcuts". This gives us a nice line in this case.
+
+![reduced DAG](./day_5_dag_reduced.svg)
+
+_no code has been written until now, this might go terribly wrong 💩_
--- a/2024/06/main.py
+++ b/2024/06/main.py
@@ -0,0 +1,89 @@
+from typing import List, Union, Tuple, Set, Self
+from dataclasses import dataclass
+
+type Point = Tuple[int, int]
+
+TURN = {
+    # (-1,0) > (0, 1) -> (1, 0) -> (0, -1)
+    (-1, 0): (0, 1),
+    (0, 1): (1, 0),
+    (1, 0): (0, -1),
+    (0, -1): (-1, 0),
+}
+
+
+@dataclass
+class Map:
+    fields: List[List[bool]]
+    position: Point
+    direction: Point
+    max_y: int = 0
+    max_x: int = 0
+
+    def __post_init__(self):
+        self.max_y = len(self.fields)
+        self.max_x = len(self.fields[0])
+
+    def next_step(self):
+        return (
+            self.position[0] + self.direction[0],
+            self.position[1] + self.direction[1],
+        )
+
+    def get(self, point: Point) -> Union[bool, None]:
+        y, x = point
+        try:
+            return self.fields[y][x]
+        except IndexError:
+            return None
+
+    def walk(self):
+        visited: Set[Point] = set()
+        while True:
+            visited.add(self.position)
+            next_step = self.next_step()
+            content = self.get(next_step)
+            if content is None:
+                # Exited map
+                break
+            if content:
+                # Turn
+                self.direction = TURN[self.direction]
+                next_step = self.next_step()
+            self.position = next_step
+
+        return len(visited)
+
+    @staticmethod
+    def parse(raw: str) -> Self:
+        fields = [[f == "#" for f in line] for line in raw.splitlines()]
+        # Find init
+        position = (0, 0)
+        direction = (-1, 0)  # Up
+        for y, line in enumerate(raw.splitlines()):
+            for x, f in enumerate(line):
+                if f == "^":
+                    position = (y, x)
+        return Map(fields, position, direction)
+
+
+def solve(raw: str) -> int:
+    # Part 1
+    part1 = 0
+    part2 = 0
+
+    m = Map.parse(raw)
+    part1 = m.walk()
+
+    return (part1, part2)
+
+
+# Test
+with open("./2024/06/test.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
+
+# Input
+with open("./2024/06/input.txt", "r") as f:
+    result = solve(f.read().strip())
+    print(result)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "advent-of-code"
+version = "0.1.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "advent-of-code"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+
+[[bin]]
+name = "2022-01"
+path = "./2022/01/rust/main.rs"
+
+[[bin]]
+name = "2022-02"
+path = "./2022/02/rust/main.rs"
+
+[[bin]]
+name = "2022-03"
+path = "./2022/03/rust/main.rs"
+
+[[bin]]
+name = "2023-01"
+path = "./2023/01/rust/main.rs"
+
+[[bin]]
+name = "2023-02"
+path = "./2023/02/rust/main.rs"
+
+[[bin]]
+name = "2023-03"
+path = "./2023/03/rust/main.rs"
+
+[[bin]]
+name = "2023-04"
+path = "./2023/04/rust/main.rs"
+
+# INJECT HERE
--- a/README.md
+++ b/README.md
@@ -1,5 +1,84 @@
 # Advent Of Code

-> New days are generated with [`hygen`](https://github.com/jondot/hygen).
+Template repository for Advent of Code. It automatically downloads your puzzle inputs and bootstraps files for the following languages:
+
+- Typescript
+- Python
+- Rust
+
+Have fun! 🤗🎄
+
+## Getting started
+
+New "days" are generated with [`hygen`](https://github.com/jondot/hygen). This will bootstrap code for python and rust. See details about the specifica languages below
+
+```bash
+# First time setup
+bun i
+
+# Put the Advent of Code token into .env (details below)
+
+# Generate day
+bun run gen --year 2022 --day 1
+```
+
+> Extracting the Advent of Code cookie
 >
-> `hygen riddle new --year 2021 --day 01`
+> 1. Navigate to https://adventofcode.com/ and login.
+> 2. Open dev tools and copy the cookie named `session`.
+> 3. save `TOKEN=<my-token>` to `.env`.
+
+## Languages
+
+Below are instructions for the specific handling of each language included.
+
+### Typescript
+
+Run a single day:
+
+```bash
+# Once
+bun run 2022/01/typescript/main.ts
+
+# Rerun on change
+bun run --watch 2022/01/typescript/main.ts
+```
+
+### Python
+
+```bash
+# Get a python enabled shell, with the latest version
+poetry shell
+
+# Run once
+python 2022/01/python/main.py
+
+# Rerun on change
+bunx nodemon 2022/01/python/main.py
+```
+
+### Rust
+
+Run a single day:
+
+```bash
+# Once
+cargo run --bin 2022-01
+
+# Rerun on change (requires: https://github.com/watchexec/cargo-watch)
+cargo watch -x 'run --bin 2022-01'
+```
+
+Benchmark a day:
+
+```bash
+cargo bench --bin 2022-01
+```
+
+Benchmark all days:
+
+```bash
+cargo bench
+```
+
+> The benchmark is the built in Rust one. This is the [reason](https://doc.rust-lang.org/cargo/commands/cargo-bench.html) for the _nightly_ version.
--- a/_templates/riddle/new/cargo.ejs.t
+++ b/_templates/riddle/new/cargo.ejs.t
@@ -0,0 +1,10 @@
+---
+inject: true
+to: cargo.toml
+before: "# INJECT HERE"
+skip_if: <%= id %> 
+---
+
+[[bin]]
+name = "<%= id %>"
+path = "<%= dir %>/rust/main.rs"
--- a/_templates/riddle/new/index.js
+++ b/_templates/riddle/new/index.js
@@ -12,6 +12,13 @@ async function getInput(year, day) {

 module.exports = {
  params: async ({ args }) => {
-    return { ...args, input: await getInput(args.year, args.day) }
+    const day = args.day.toString().padStart(2, '0') // Padded
+    return {
+      ...args,
+      id: `${args.year}-${day}`,
+      dir: `./${args.year}/${day}`,
+      input: await getInput(args.year, parseInt(day)),
+      day,
+    }
  },
 }
--- a/_templates/riddle/new/input.txt.t
+++ b/_templates/riddle/new/input.txt.t
@@ -1,5 +1,5 @@
 ---
-to: <%= year %>/<%= day %>/input.txt
+to: <%= dir %>/input.txt
 unless_exists: true
 ---
 <%= input %>
--- a/_templates/riddle/new/python.ejs.t
+++ b/_templates/riddle/new/python.ejs.t
@@ -1,14 +1,12 @@
 ---
-to: <%= year %>/<%= day %>/python/main.py
+to: <%= dir %>/python/main.py
 unless_exists: true
 ---
 #!/usr/bin/env python

 from os.path import join, dirname

-# Day <%= day %>
-
-# Common
+# Setup


 def read_input(filename):
@@ -17,7 +15,25 @@ def read_input(filename):
        return f.read().strip()


-test = read_input('test.txt')
-data = read_input('input.txt')
+TEST = read_input('test.txt')
+INPUT = read_input('input.txt')
+
+# Task
+
+def part_a(raw: str):
+    pass
+
+
+def part_b(raw: str):
+    pass

 # Running
+
+print('1.')
+print(part_a(TEST))
+print(part_a(INPUT))
+
+print('\n2.')
+print('1.')
+print(part_b(TEST))
+print(part_b(INPUT))
--- a/_templates/riddle/new/readme.ejs.t
+++ b/_templates/riddle/new/readme.ejs.t
@@ -1,5 +1,5 @@
 ---
-to: <%= year %>/<%= day %>/README.md
+to: <%= dir %>/README.md
 unless_exists: true
 ---

--- a/_templates/riddle/new/rust.ejs.t
+++ b/_templates/riddle/new/rust.ejs.t
@@ -0,0 +1,46 @@
+---
+to: <%= dir %>/rust/main.rs
+unless_exists: true
+---
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::Bencher;
+
+    #[bench]
+    fn bench_a(b: &mut Bencher) {
+        b.iter(|| part_a(INPUT));
+    }
+
+    #[bench]
+    fn bench_b(b: &mut Bencher) {
+        b.iter(|| part_b(INPUT));
+    }
+}
+
+const INPUT: &str = include_str!("../input.txt");
+const TEST: &str = include_str!("../test.txt");
+
+fn part_a(input: &str) {
+    let result = input.trim();
+    println!("{}", result);
+}
+
+fn part_b(input: &str) {
+    let result = input.trim();
+    println!("{}", result);
+}
+
+fn main() {
+    println!("Part A:");
+    part_a(TEST);
+    // part_a(INPUT);
+
+    println!("\nPart B:");
+    part_b(TEST);
+    // part_b(INPUT);
+}
--- a/_templates/riddle/new/test.txt.t
+++ b/_templates/riddle/new/test.txt.t
@@ -1,4 +1,4 @@
 ---
-to: <%= year %>/<%= day %>/test.txt
+to: <%= dir %>/test.txt
 unless_exists: true
 ---
--- a/_templates/riddle/new/typescript.ejs.t
+++ b/_templates/riddle/new/typescript.ejs.t
@@ -0,0 +1,24 @@
+---
+to: <%= dir %>/typescript/main.ts
+unless_exists: true
+---
+import fs from 'node:fs'
+import path from 'node:path'
+
+// SETUP
+const INPUT = fs.readFileSync(path.join(import.meta.dir, '../input.txt'), 'utf-8').trim()
+const TEST = fs.readFileSync(path.join(import.meta.dir, '../test.txt'), 'utf-8').trim()
+
+// TASK
+
+function partA(input: string) {}
+
+function partB(input: string) {}
+
+console.log('Part A:')
+partA(TEST)
+partA(INPUT)
+
+console.log('Part B:')
+partA(TEST)
+partB(INPUT)
--- a/bun.lockb
+++ b/bun.lockb
--- a/package.json
+++ b/package.json
@@ -1,6 +1,12 @@
 {
+  "scripts": {
+    "gen": "bun hygen riddle new"
+  },
  "dependencies": {
+    "@tsconfig/strictest": "^2.0.2",
    "axios": "^1.6.0",
-    "hygen": "^6.2.11"
+    "bun-types": "latest",
+    "hygen": "^6.2.11",
+    "typescript": "^5.0.0"
  }
 }
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,98 +0,0 @@
-# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand.
-
-[[package]]
-name = "autopep8"
-version = "2.0.4"
-description = "A tool that automatically formats Python code to conform to the PEP 8 style guide"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "autopep8-2.0.4-py2.py3-none-any.whl", hash = "sha256:067959ca4a07b24dbd5345efa8325f5f58da4298dab0dde0443d5ed765de80cb"},
-    {file = "autopep8-2.0.4.tar.gz", hash = "sha256:2913064abd97b3419d1cc83ea71f042cb821f87e45b9c88cad5ad3c4ea87fe0c"},
-]
-
-[package.dependencies]
-pycodestyle = ">=2.10.0"
-
-[[package]]
-name = "mypy"
-version = "1.6.1"
-description = "Optional static typing for Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "mypy-1.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e5012e5cc2ac628177eaac0e83d622b2dd499e28253d4107a08ecc59ede3fc2c"},
-    {file = "mypy-1.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d8fbb68711905f8912e5af474ca8b78d077447d8f3918997fecbf26943ff3cbb"},
-    {file = "mypy-1.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a1ad938fee7d2d96ca666c77b7c494c3c5bd88dff792220e1afbebb2925b5e"},
-    {file = "mypy-1.6.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b96ae2c1279d1065413965c607712006205a9ac541895004a1e0d4f281f2ff9f"},
-    {file = "mypy-1.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:40b1844d2e8b232ed92e50a4bd11c48d2daa351f9deee6c194b83bf03e418b0c"},
-    {file = "mypy-1.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:81af8adaa5e3099469e7623436881eff6b3b06db5ef75e6f5b6d4871263547e5"},
-    {file = "mypy-1.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8c223fa57cb154c7eab5156856c231c3f5eace1e0bed9b32a24696b7ba3c3245"},
-    {file = "mypy-1.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8032e00ce71c3ceb93eeba63963b864bf635a18f6c0c12da6c13c450eedb183"},
-    {file = "mypy-1.6.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4c46b51de523817a0045b150ed11b56f9fff55f12b9edd0f3ed35b15a2809de0"},
-    {file = "mypy-1.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:19f905bcfd9e167159b3d63ecd8cb5e696151c3e59a1742e79bc3bcb540c42c7"},
-    {file = "mypy-1.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:82e469518d3e9a321912955cc702d418773a2fd1e91c651280a1bda10622f02f"},
-    {file = "mypy-1.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d4473c22cc296425bbbce7e9429588e76e05bc7342da359d6520b6427bf76660"},
-    {file = "mypy-1.6.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59a0d7d24dfb26729e0a068639a6ce3500e31d6655df8557156c51c1cb874ce7"},
-    {file = "mypy-1.6.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:cfd13d47b29ed3bbaafaff7d8b21e90d827631afda134836962011acb5904b71"},
-    {file = "mypy-1.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:eb4f18589d196a4cbe5290b435d135dee96567e07c2b2d43b5c4621b6501531a"},
-    {file = "mypy-1.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:41697773aa0bf53ff917aa077e2cde7aa50254f28750f9b88884acea38a16169"},
-    {file = "mypy-1.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7274b0c57737bd3476d2229c6389b2ec9eefeb090bbaf77777e9d6b1b5a9d143"},
-    {file = "mypy-1.6.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbaf4662e498c8c2e352da5f5bca5ab29d378895fa2d980630656178bd607c46"},
-    {file = "mypy-1.6.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bb8ccb4724f7d8601938571bf3f24da0da791fe2db7be3d9e79849cb64e0ae85"},
-    {file = "mypy-1.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:68351911e85145f582b5aa6cd9ad666c8958bcae897a1bfda8f4940472463c45"},
-    {file = "mypy-1.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:49ae115da099dcc0922a7a895c1eec82c1518109ea5c162ed50e3b3594c71208"},
-    {file = "mypy-1.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8b27958f8c76bed8edaa63da0739d76e4e9ad4ed325c814f9b3851425582a3cd"},
-    {file = "mypy-1.6.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:925cd6a3b7b55dfba252b7c4561892311c5358c6b5a601847015a1ad4eb7d332"},
-    {file = "mypy-1.6.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8f57e6b6927a49550da3d122f0cb983d400f843a8a82e65b3b380d3d7259468f"},
-    {file = "mypy-1.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:a43ef1c8ddfdb9575691720b6352761f3f53d85f1b57d7745701041053deff30"},
-    {file = "mypy-1.6.1-py3-none-any.whl", hash = "sha256:4cbe68ef919c28ea561165206a2dcb68591c50f3bcf777932323bc208d949cf1"},
-    {file = "mypy-1.6.1.tar.gz", hash = "sha256:4d01c00d09a0be62a4ca3f933e315455bde83f37f892ba4b08ce92f3cf44bcc1"},
-]
-
-[package.dependencies]
-mypy-extensions = ">=1.0.0"
-typing-extensions = ">=4.1.0"
-
-[package.extras]
-dmypy = ["psutil (>=4.0)"]
-install-types = ["pip"]
-reports = ["lxml"]
-
-[[package]]
-name = "mypy-extensions"
-version = "1.0.0"
-description = "Type system extensions for programs checked with the mypy type checker."
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
-    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
-]
-
-[[package]]
-name = "pycodestyle"
-version = "2.11.1"
-description = "Python style guide checker"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pycodestyle-2.11.1-py2.py3-none-any.whl", hash = "sha256:44fe31000b2d866f2e41841b18528a505fbd7fef9017b04eff4e2648a0fadc67"},
-    {file = "pycodestyle-2.11.1.tar.gz", hash = "sha256:41ba0e7afc9752dfb53ced5489e89f8186be00e599e712660695b7a75ff2663f"},
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.8.0"
-description = "Backported and Experimental Type Hints for Python 3.8+"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "typing_extensions-4.8.0-py3-none-any.whl", hash = "sha256:8f92fc8806f9a6b641eaa5318da32b44d401efaac0f6678c9bc448ba3605faa0"},
-    {file = "typing_extensions-4.8.0.tar.gz", hash = "sha256:df8e4339e9cb77357558cbdbceca33c303714cf861d1eef15e1070055ae8b7ef"},
-]
-
-[metadata]
-lock-version = "2.0"
-python-versions = "^3.12"
-content-hash = "c0841b3329ba8068bf9206c87702cc70f932d2980d9fb05e3501c28378b87642"
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,19 +1,7 @@
-[tool.poetry]
-name = "advent-of-code"
+[project]
+name = "aoc"
 version = "0.1.0"
-description = ""
-authors = ["cupcakearmy <hi@nicco.io>"]
+description = "Add your description here"
 readme = "README.md"
-packages = [{include = "advent_of_code"}]
-
-[tool.poetry.dependencies]
-python = "^3.12"
-
-
-[tool.poetry.group.dev.dependencies]
-mypy = "^1.6.1"
-autopep8 = "^2.0.4"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires-python = ">=3.12"
+dependencies = ["matplotlib>=3.9.3", "networkx[default]>=3.4.2"]
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": ["@tsconfig/strictest"],
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "noEmit": true,
+    "types": ["bun-types"]
+  }
+}
--- a/uv.lock
+++ b/uv.lock
@@ -0,0 +1,380 @@
+version = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "aoc"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "matplotlib" },
+    { name = "networkx", extra = ["default"] },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "matplotlib", specifier = ">=3.9.3" },
+    { name = "networkx", extras = ["default"], specifier = ">=3.4.2" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 },
+    { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 },
+    { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 },
+    { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 },
+    { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 },
+    { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 },
+    { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 },
+    { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 },
+    { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 },
+    { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 },
+    { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 },
+    { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 },
+    { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 },
+    { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 },
+    { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 },
+    { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 },
+    { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 },
+    { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 },
+    { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 },
+    { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 },
+    { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 },
+    { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 },
+    { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 },
+    { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 },
+    { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 },
+    { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 },
+    { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 },
+    { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 },
+    { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.55.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/3a/6ab28db8f90c99e6b502436fb642912b590c352d5ba83e0b22b46db209da/fonttools-4.55.2.tar.gz", hash = "sha256:45947e7b3f9673f91df125d375eb57b9a23f2a603f438a1aebf3171bffa7a205", size = 3492954 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/62/7ac990a52c2bb249e9de6de0036a24eba5a5a8e8446819ab5a5751a0a45e/fonttools-4.55.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:18f082445b8fe5e91c53e6184f4c1c73f3f965c8bcc614c6cd6effd573ce6c1a", size = 2754521 },
+    { url = "https://files.pythonhosted.org/packages/4a/bd/a8034bf5d685f825cec0aca6759639277b1d3b0b1d38842b5f30edfb4176/fonttools-4.55.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:27c0f91adbbd706e8acd1db73e3e510118e62d0ffb651864567dccc5b2339f90", size = 2287092 },
+    { url = "https://files.pythonhosted.org/packages/70/ad/edf4f4e0efdda8205893007d30d62da09f92d3f0b0f1a3faf85bd5df9952/fonttools-4.55.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d8ccce035320d63dba0c35f52499322f5531dbe85bba1514c7cea26297e4c54", size = 4782490 },
+    { url = "https://files.pythonhosted.org/packages/7a/5f/f757e5860cc4f187fdf8eacf53abc92613cdbc55355e13ba07e2c937d217/fonttools-4.55.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96e126df9615df214ec7f04bebcf60076297fbc10b75c777ce58b702d7708ffb", size = 4854787 },
+    { url = "https://files.pythonhosted.org/packages/92/1b/c647b89e5603f9ae9b8f14885dfaf523351eb9d0b5dcbafaf1512d0d4d97/fonttools-4.55.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:508ebb42956a7a931c4092dfa2d9b4ffd4f94cea09b8211199090d2bd082506b", size = 4763330 },
+    { url = "https://files.pythonhosted.org/packages/57/09/117e2b5b2d2fcd607b360e241939a652505577c752f9ca15b2fb9e4fc540/fonttools-4.55.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1b9de46ef7b683d50400abf9f1578eaceee271ff51c36bf4b7366f2be29f498", size = 4990999 },
+    { url = "https://files.pythonhosted.org/packages/b9/e5/9be5bd4bfb83187fb83f46b9be6676f653c08a430b975e0a3355fd248c37/fonttools-4.55.2-cp312-cp312-win32.whl", hash = "sha256:2df61d9fc15199cc86dad29f64dd686874a3a52dda0c2d8597d21f509f95c332", size = 2151234 },
+    { url = "https://files.pythonhosted.org/packages/f3/c5/0eda5db19bd5fe3f6b8dc30ca5be512999b4923268b9b82fd14c211217b5/fonttools-4.55.2-cp312-cp312-win_amd64.whl", hash = "sha256:d337ec087da8216a828574aa0525d869df0a2ac217a2efc1890974ddd1fbc5b9", size = 2198133 },
+    { url = "https://files.pythonhosted.org/packages/2d/94/f941fa68a1d4a0f2facd5e6476ae91c5683aea7b7cc30d3ef49187cbbc67/fonttools-4.55.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:10aff204e2edee1d312fa595c06f201adf8d528a3b659cfb34cd47eceaaa6a26", size = 2741975 },
+    { url = "https://files.pythonhosted.org/packages/c5/61/00015fe3ccc8171b4d4afb0fa5155064f68948138ef5e1a5ac9cb49082c4/fonttools-4.55.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:09fe922a3eff181fd07dd724cdb441fb6b9fc355fd1c0f1aa79aca60faf1fbdd", size = 2280680 },
+    { url = "https://files.pythonhosted.org/packages/4e/fe/9bb6cedc47a9e3872e138e4328475d4ff4faea7d87a2316dc5e5e4cd305e/fonttools-4.55.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:487e1e8b524143a799bda0169c48b44a23a6027c1bb1957d5a172a7d3a1dd704", size = 4760147 },
+    { url = "https://files.pythonhosted.org/packages/a2/3a/5bbe1b2a01f6bdf911aca48941eb317a678b50fccf63a27298289af79023/fonttools-4.55.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b1726872e09268bbedb14dc02e58b7ea31ecdd1204c6073eda4911746b44797", size = 4834697 },
+    { url = "https://files.pythonhosted.org/packages/43/21/6bb77d4c90e0333db2f5059476fe2f74ad706d9117e82508756c78c7b9be/fonttools-4.55.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6fc88cfb58b0cd7b48718c3e61dd0d0a3ee8e2c86b973342967ce09fbf1db6d4", size = 4743076 },
+    { url = "https://files.pythonhosted.org/packages/90/0b/21392ffe6f9ffb1eefd06363401c68815434faed22cebf00337f513ee41f/fonttools-4.55.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e857fe1859901ad8c5cab32e0eebc920adb09f413d2d73b74b677cf47b28590c", size = 4965579 },
+    { url = "https://files.pythonhosted.org/packages/f6/c8/c5aed715d3816977451d2eaf4ab3aaad48e8d8a3e25d28a4d29a07b0f841/fonttools-4.55.2-cp313-cp313-win32.whl", hash = "sha256:81ccd2b3a420b8050c7d9db3be0555d71662973b3ef2a1d921a2880b58957db8", size = 2149187 },
+    { url = "https://files.pythonhosted.org/packages/c4/07/36df0ee4ba78b8eb4880b8bbc0d96cc97b98d358ff4a74b469bda851f63e/fonttools-4.55.2-cp313-cp313-win_amd64.whl", hash = "sha256:d559eb1744c7dcfa90ae60cb1a4b3595e898e48f4198738c321468c01180cd83", size = 2195113 },
+    { url = "https://files.pythonhosted.org/packages/69/94/c4d8dfe26a971e00e34df99b46e9518425f59918c8993830e904171e21f9/fonttools-4.55.2-py3-none-any.whl", hash = "sha256:8e2d89fbe9b08d96e22c7a81ec04a4e8d8439c31223e2dc6f2f9fc8ff14bdf9f", size = 1100792 },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808 },
+    { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531 },
+    { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894 },
+    { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296 },
+    { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450 },
+    { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168 },
+    { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308 },
+    { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186 },
+    { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877 },
+    { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204 },
+    { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461 },
+    { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358 },
+    { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119 },
+    { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367 },
+    { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884 },
+    { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528 },
+    { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913 },
+    { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627 },
+    { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888 },
+    { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145 },
+    { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448 },
+    { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750 },
+    { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175 },
+    { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963 },
+    { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220 },
+    { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463 },
+    { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842 },
+    { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635 },
+    { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556 },
+    { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364 },
+    { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887 },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530 },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/75/9f/562ed484b11ac9f4bb4f9d2d7546954ec106a8c0f06cc755d6f63e519274/matplotlib-3.9.3.tar.gz", hash = "sha256:cd5dbbc8e25cad5f706845c4d100e2c8b34691b412b93717ce38d8ae803bcfa5", size = 36113438 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/d5/eb2338d21b2d36511f9417230413fa0c30fc82283b33dc0e3643969f3b50/matplotlib-3.9.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0a361bd5583bf0bcc08841df3c10269617ee2a36b99ac39d455a767da908bbbc", size = 7883049 },
+    { url = "https://files.pythonhosted.org/packages/e5/52/3910833a073e7182ab3ae03810ed418f71c7fdcd65e2862cda1c6a14ffc1/matplotlib-3.9.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e14485bb1b83eeb3d55b6878f9560240981e7bbc7a8d4e1e8c38b9bd6ec8d2de", size = 7768285 },
+    { url = "https://files.pythonhosted.org/packages/92/67/69df4b6636e40e964788b003535561ea3e98e33e46df4d96fa8c34ef99e6/matplotlib-3.9.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a8d279f78844aad213c4935c18f8292a9432d51af2d88bca99072c903948045", size = 8192626 },
+    { url = "https://files.pythonhosted.org/packages/40/d6/70a196b0cf62e0a5bc64ccab07816ab4f6c98db0414a55280331a481a5bf/matplotlib-3.9.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6c12514329ac0d03128cf1dcceb335f4fbf7c11da98bca68dca8dcb983153a9", size = 8305687 },
+    { url = "https://files.pythonhosted.org/packages/c3/43/ef6ab78dd2d8eb362c1e5a31f9cec5ece5761e6143a519153d716d85e590/matplotlib-3.9.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6e9de2b390d253a508dd497e9b5579f3a851f208763ed67fdca5dc0c3ea6849c", size = 9087208 },
+    { url = "https://files.pythonhosted.org/packages/30/cb/36844affc69490652b5a99296b9fcee530b96621e23d3143a4839f30fb22/matplotlib-3.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:d796272408f8567ff7eaa00eb2856b3a00524490e47ad505b0b4ca6bb8a7411f", size = 7833105 },
+    { url = "https://files.pythonhosted.org/packages/60/04/949640040982822416c471d9ebe4e9e6c69ca9f9bb6ba82ed30808863c02/matplotlib-3.9.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:203d18df84f5288973b2d56de63d4678cc748250026ca9e1ad8f8a0fd8a75d83", size = 7883417 },
+    { url = "https://files.pythonhosted.org/packages/9f/90/ebd37143cd3150b6c650ee1580024df3dd649d176e68d346f826b8d24e37/matplotlib-3.9.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b651b0d3642991259109dc0351fc33ad44c624801367bb8307be9bfc35e427ad", size = 7768720 },
+    { url = "https://files.pythonhosted.org/packages/dc/84/6591e6b55d755d16dacdc113205067031867c1f5e3c08b32c01aad831420/matplotlib-3.9.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:66d7b171fecf96940ce069923a08ba3df33ef542de82c2ff4fe8caa8346fa95a", size = 8192723 },
+    { url = "https://files.pythonhosted.org/packages/29/09/146a17d37e32313507f11ac984e65311f2d5805d731eb981d4f70eb928dc/matplotlib-3.9.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6be0ba61f6ff2e6b68e4270fb63b6813c9e7dec3d15fc3a93f47480444fd72f0", size = 8305801 },
+    { url = "https://files.pythonhosted.org/packages/85/cb/d2690572c08f19ca7c0f44b1fb4d11c121d63467a57b508cc3656ff80b43/matplotlib-3.9.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d6b2e8856dec3a6db1ae51aec85c82223e834b228c1d3228aede87eee2b34f9", size = 9086564 },
+    { url = "https://files.pythonhosted.org/packages/28/dd/0a5176027c1cb94fe75f69f76cb274180c8abf740df6fc0e6a1e4cbaec3f/matplotlib-3.9.3-cp313-cp313-win_amd64.whl", hash = "sha256:90a85a004fefed9e583597478420bf904bb1a065b0b0ee5b9d8d31b04b0f3f70", size = 7833257 },
+    { url = "https://files.pythonhosted.org/packages/42/d4/e477d50a8e4b437c2afbb5c665cb8e5d79b06abe6fe3c6915d6f7f0c2ef2/matplotlib-3.9.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3119b2f16de7f7b9212ba76d8fe6a0e9f90b27a1e04683cd89833a991682f639", size = 7911906 },
+    { url = "https://files.pythonhosted.org/packages/ae/a1/ba5ab89666c42ace8e31b4ff5a2c76a17e4d6f91aefce476b064c56ff61d/matplotlib-3.9.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:87ad73763d93add1b6c1f9fcd33af662fd62ed70e620c52fcb79f3ac427cf3a6", size = 7801336 },
+    { url = "https://files.pythonhosted.org/packages/77/59/4dcdb3a6695af6c698a95aec13016a550ef2f85144d22f61f81d1e064148/matplotlib-3.9.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:026bdf3137ab6022c866efa4813b6bbeddc2ed4c9e7e02f0e323a7bca380dfa0", size = 8218178 },
+    { url = "https://files.pythonhosted.org/packages/4f/27/7c72db0d0ee35d9237572565ffa3c0eb25fc46a3f47e0f16412a587bc9d8/matplotlib-3.9.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:760a5e89ebbb172989e8273024a1024b0f084510b9105261b3b00c15e9c9f006", size = 8327768 },
+    { url = "https://files.pythonhosted.org/packages/de/ad/213eee624feadba7b77e881c9d2c04c1e036efe69d19031e3fa927fdb5dc/matplotlib-3.9.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a42b9dc42de2cfe357efa27d9c50c7833fc5ab9b2eb7252ccd5d5f836a84e1e4", size = 9094075 },
+    { url = "https://files.pythonhosted.org/packages/19/1b/cb8e99a5fe2e2b14e3b8234cb1649a675be63f74a5224a648ae4ab61f60c/matplotlib-3.9.3-cp313-cp313t-win_amd64.whl", hash = "sha256:e0fcb7da73fbf67b5f4bdaa57d85bb585a4e913d4a10f3e15b32baea56a67f0a", size = 7888937 },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 },
+]
+
+[package.optional-dependencies]
+default = [
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "scipy" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/1b/1d565e0f6e156e1522ab564176b8b29d71e13d8caf003a08768df3d5cec5/numpy-2.2.0.tar.gz", hash = "sha256:140dd80ff8981a583a60980be1a655068f8adebf7a45a06a6858c873fcdcd4a0", size = 20225497 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/bc/a20dc4e1d051149052762e7647455311865d11c603170c476d1e910a353e/numpy-2.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cff210198bb4cae3f3c100444c5eaa573a823f05c253e7188e1362a5555235b3", size = 20909153 },
+    { url = "https://files.pythonhosted.org/packages/60/3d/ac4fb63f36db94f4c7db05b45e3ecb3f88f778ca71850664460c78cfde41/numpy-2.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b92a5828bd4d9aa0952492b7de803135038de47343b2aa3cc23f3b71a3dc4e", size = 14095021 },
+    { url = "https://files.pythonhosted.org/packages/41/6d/a654d519d24e4fcc7a83d4a51209cda086f26cf30722b3d8ffc1aa9b775e/numpy-2.2.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:ebe5e59545401fbb1b24da76f006ab19734ae71e703cdb4a8b347e84a0cece67", size = 5125491 },
+    { url = "https://files.pythonhosted.org/packages/e6/22/fab7e1510a62e5092f4e6507a279020052b89f11d9cfe52af7f52c243b04/numpy-2.2.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e2b8cd48a9942ed3f85b95ca4105c45758438c7ed28fff1e4ce3e57c3b589d8e", size = 6658534 },
+    { url = "https://files.pythonhosted.org/packages/fc/29/a3d938ddc5a534cd53df7ab79d20a68db8c67578de1df0ae0118230f5f54/numpy-2.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57fcc997ffc0bef234b8875a54d4058afa92b0b0c4223fc1f62f24b3b5e86038", size = 14046306 },
+    { url = "https://files.pythonhosted.org/packages/90/24/d0bbb56abdd8934f30384632e3c2ca1ebfeb5d17e150c6e366ba291de36b/numpy-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85ad7d11b309bd132d74397fcf2920933c9d1dc865487128f5c03d580f2c3d03", size = 16095819 },
+    { url = "https://files.pythonhosted.org/packages/99/9c/58a673faa9e8a0e77248e782f7a17410cf7259b326265646fd50ed49c4e1/numpy-2.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cb24cca1968b21355cc6f3da1a20cd1cebd8a023e3c5b09b432444617949085a", size = 15243215 },
+    { url = "https://files.pythonhosted.org/packages/9c/61/f311693f78cbf635cfb69ce9e1e857ff83937a27d93c96ac5932fd33e330/numpy-2.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0798b138c291d792f8ea40fe3768610f3c7dd2574389e37c3f26573757c8f7ef", size = 17860175 },
+    { url = "https://files.pythonhosted.org/packages/11/3e/491c34262cb1fc9dd13a00beb80d755ee0517b17db20e54cac7aa524533e/numpy-2.2.0-cp312-cp312-win32.whl", hash = "sha256:afe8fb968743d40435c3827632fd36c5fbde633b0423da7692e426529b1759b1", size = 6273281 },
+    { url = "https://files.pythonhosted.org/packages/89/ea/00537f599eb230771157bc509f6ea5b2dddf05d4b09f9d2f1d7096a18781/numpy-2.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:3a4199f519e57d517ebd48cb76b36c82da0360781c6a0353e64c0cac30ecaad3", size = 12613227 },
+    { url = "https://files.pythonhosted.org/packages/bd/4c/0d1eef206545c994289e7a9de21b642880a11e0ed47a2b0c407c688c4f69/numpy-2.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f8c8b141ef9699ae777c6278b52c706b653bf15d135d302754f6b2e90eb30367", size = 20895707 },
+    { url = "https://files.pythonhosted.org/packages/16/cb/88f6c1e6df83002c421d5f854ccf134aa088aa997af786a5dac3f32ec99b/numpy-2.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f0986e917aca18f7a567b812ef7ca9391288e2acb7a4308aa9d265bd724bdae", size = 14110592 },
+    { url = "https://files.pythonhosted.org/packages/b4/54/817e6894168a43f33dca74199ba0dd0f1acd99aa6323ed6d323d63d640a2/numpy-2.2.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:1c92113619f7b272838b8d6702a7f8ebe5edea0df48166c47929611d0b4dea69", size = 5110858 },
+    { url = "https://files.pythonhosted.org/packages/c7/99/00d8a1a8eb70425bba7880257ed73fed08d3e8d05da4202fb6b9a81d5ee4/numpy-2.2.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5a145e956b374e72ad1dff82779177d4a3c62bc8248f41b80cb5122e68f22d13", size = 6645143 },
+    { url = "https://files.pythonhosted.org/packages/34/86/5b9c2b7c56e7a9d9297a0a4be0b8433f498eba52a8f5892d9132b0f64627/numpy-2.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18142b497d70a34b01642b9feabb70156311b326fdddd875a9981f34a369b671", size = 14042812 },
+    { url = "https://files.pythonhosted.org/packages/df/54/13535f74391dbe5f479ceed96f1403267be302c840040700d4fd66688089/numpy-2.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7d41d1612c1a82b64697e894b75db6758d4f21c3ec069d841e60ebe54b5b571", size = 16093419 },
+    { url = "https://files.pythonhosted.org/packages/dd/37/dfb2056842ac61315f225aa56f455da369f5223e4c5a38b91d20da1b628b/numpy-2.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a98f6f20465e7618c83252c02041517bd2f7ea29be5378f09667a8f654a5918d", size = 15238969 },
+    { url = "https://files.pythonhosted.org/packages/5a/3d/d20d24ee313992f0b7e7b9d9eef642d9b545d39d5b91c4a2cc8c98776328/numpy-2.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e09d40edfdb4e260cb1567d8ae770ccf3b8b7e9f0d9b5c2a9992696b30ce2742", size = 17855705 },
+    { url = "https://files.pythonhosted.org/packages/5b/40/944c9ee264f875a2db6f79380944fd2b5bb9d712bb4a134d11f45ad5b693/numpy-2.2.0-cp313-cp313-win32.whl", hash = "sha256:3905a5fffcc23e597ee4d9fb3fcd209bd658c352657548db7316e810ca80458e", size = 6270078 },
+    { url = "https://files.pythonhosted.org/packages/30/04/e1ee6f8b22034302d4c5c24e15782bdedf76d90b90f3874ed0b48525def0/numpy-2.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a184288538e6ad699cbe6b24859206e38ce5fba28f3bcfa51c90d0502c1582b2", size = 12605791 },
+    { url = "https://files.pythonhosted.org/packages/ef/fb/51d458625cd6134d60ac15180ae50995d7d21b0f2f92a6286ae7b0792d19/numpy-2.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7832f9e8eb00be32f15fdfb9a981d6955ea9adc8574c521d48710171b6c55e95", size = 20920160 },
+    { url = "https://files.pythonhosted.org/packages/b4/34/162ae0c5d2536ea4be98c813b5161c980f0443cd5765fde16ddfe3450140/numpy-2.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f0dd071b95bbca244f4cb7f70b77d2ff3aaaba7fa16dc41f58d14854a6204e6c", size = 14119064 },
+    { url = "https://files.pythonhosted.org/packages/17/6c/4195dd0e1c41c55f466d516e17e9e28510f32af76d23061ea3da67438e3c/numpy-2.2.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b0b227dcff8cdc3efbce66d4e50891f04d0a387cce282fe1e66199146a6a8fca", size = 5152778 },
+    { url = "https://files.pythonhosted.org/packages/2f/47/ea804ae525832c8d05ed85b560dfd242d34e4bb0962bc269ccaa720fb934/numpy-2.2.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ab153263a7c5ccaf6dfe7e53447b74f77789f28ecb278c3b5d49db7ece10d6d", size = 6667605 },
+    { url = "https://files.pythonhosted.org/packages/76/99/34d20e50b3d894bb16b5374bfbee399ab8ff3a33bf1e1f0b8acfe7bbd70d/numpy-2.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e500aba968a48e9019e42c0c199b7ec0696a97fa69037bea163b55398e390529", size = 14013275 },
+    { url = "https://files.pythonhosted.org/packages/69/8f/a1df7bd02d434ab82539517d1b98028985700cfc4300bc5496fb140ca648/numpy-2.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:440cfb3db4c5029775803794f8638fbdbf71ec702caf32735f53b008e1eaece3", size = 16074900 },
+    { url = "https://files.pythonhosted.org/packages/04/94/b419e7a76bf21a00fcb03c613583f10e389fdc8dfe420412ff5710c8ad3d/numpy-2.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a55dc7a7f0b6198b07ec0cd445fbb98b05234e8b00c5ac4874a63372ba98d4ab", size = 15219122 },
+    { url = "https://files.pythonhosted.org/packages/65/d9/dddf398b2b6c5d750892a207a469c2854a8db0f033edaf72103af8cf05aa/numpy-2.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4bddbaa30d78c86329b26bd6aaaea06b1e47444da99eddac7bf1e2fab717bd72", size = 17851668 },
+    { url = "https://files.pythonhosted.org/packages/d4/dc/09a4e5819a9782a213c0eb4eecacdc1cd75ad8dac99279b04cfccb7eeb0a/numpy-2.2.0-cp313-cp313t-win32.whl", hash = "sha256:30bf971c12e4365153afb31fc73f441d4da157153f3400b82db32d04de1e4066", size = 6325288 },
+    { url = "https://files.pythonhosted.org/packages/ce/e1/e0d06ec34036c92b43aef206efe99a5f5f04e12c776eab82a36e00c40afc/numpy-2.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d35717333b39d1b6bb8433fa758a55f1081543de527171543a2b710551d40881", size = 12692303 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+]
+
+[[package]]
+name = "pandas"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 },
+    { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 },
+    { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 },
+    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 },
+    { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 },
+    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 },
+    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 },
+    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
+    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 },
+    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 },
+    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
+    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 },
+    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
+    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
+    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 },
+    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 },
+    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 },
+    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
+]
+
+[[package]]
+name = "pillow"
+version = "11.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/26/0d95c04c868f6bdb0c447e3ee2de5564411845e36a858cfd63766bc7b563/pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739", size = 46737780 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/a3/26e606ff0b2daaf120543e537311fa3ae2eb6bf061490e4fea51771540be/pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923", size = 3147642 },
+    { url = "https://files.pythonhosted.org/packages/4f/d5/1caabedd8863526a6cfa44ee7a833bd97f945dc1d56824d6d76e11731939/pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903", size = 2978999 },
+    { url = "https://files.pythonhosted.org/packages/d9/ff/5a45000826a1aa1ac6874b3ec5a856474821a1b59d838c4f6ce2ee518fe9/pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4", size = 4196794 },
+    { url = "https://files.pythonhosted.org/packages/9d/21/84c9f287d17180f26263b5f5c8fb201de0f88b1afddf8a2597a5c9fe787f/pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f", size = 4300762 },
+    { url = "https://files.pythonhosted.org/packages/84/39/63fb87cd07cc541438b448b1fed467c4d687ad18aa786a7f8e67b255d1aa/pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9", size = 4210468 },
+    { url = "https://files.pythonhosted.org/packages/7f/42/6e0f2c2d5c60f499aa29be14f860dd4539de322cd8fb84ee01553493fb4d/pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7", size = 4381824 },
+    { url = "https://files.pythonhosted.org/packages/31/69/1ef0fb9d2f8d2d114db982b78ca4eeb9db9a29f7477821e160b8c1253f67/pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6", size = 4296436 },
+    { url = "https://files.pythonhosted.org/packages/44/ea/dad2818c675c44f6012289a7c4f46068c548768bc6c7f4e8c4ae5bbbc811/pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc", size = 4429714 },
+    { url = "https://files.pythonhosted.org/packages/af/3a/da80224a6eb15bba7a0dcb2346e2b686bb9bf98378c0b4353cd88e62b171/pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6", size = 2249631 },
+    { url = "https://files.pythonhosted.org/packages/57/97/73f756c338c1d86bb802ee88c3cab015ad7ce4b838f8a24f16b676b1ac7c/pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47", size = 2567533 },
+    { url = "https://files.pythonhosted.org/packages/0b/30/2b61876e2722374558b871dfbfcbe4e406626d63f4f6ed92e9c8e24cac37/pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25", size = 2254890 },
+    { url = "https://files.pythonhosted.org/packages/63/24/e2e15e392d00fcf4215907465d8ec2a2f23bcec1481a8ebe4ae760459995/pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699", size = 3147300 },
+    { url = "https://files.pythonhosted.org/packages/43/72/92ad4afaa2afc233dc44184adff289c2e77e8cd916b3ddb72ac69495bda3/pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38", size = 2978742 },
+    { url = "https://files.pythonhosted.org/packages/9e/da/c8d69c5bc85d72a8523fe862f05ababdc52c0a755cfe3d362656bb86552b/pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2", size = 4194349 },
+    { url = "https://files.pythonhosted.org/packages/cd/e8/686d0caeed6b998351d57796496a70185376ed9c8ec7d99e1d19ad591fc6/pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2", size = 4298714 },
+    { url = "https://files.pythonhosted.org/packages/ec/da/430015cec620d622f06854be67fd2f6721f52fc17fca8ac34b32e2d60739/pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527", size = 4208514 },
+    { url = "https://files.pythonhosted.org/packages/44/ae/7e4f6662a9b1cb5f92b9cc9cab8321c381ffbee309210940e57432a4063a/pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa", size = 4380055 },
+    { url = "https://files.pythonhosted.org/packages/74/d5/1a807779ac8a0eeed57f2b92a3c32ea1b696e6140c15bd42eaf908a261cd/pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f", size = 4296751 },
+    { url = "https://files.pythonhosted.org/packages/38/8c/5fa3385163ee7080bc13026d59656267daaaaf3c728c233d530e2c2757c8/pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb", size = 4430378 },
+    { url = "https://files.pythonhosted.org/packages/ca/1d/ad9c14811133977ff87035bf426875b93097fb50af747793f013979facdb/pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798", size = 2249588 },
+    { url = "https://files.pythonhosted.org/packages/fb/01/3755ba287dac715e6afdb333cb1f6d69740a7475220b4637b5ce3d78cec2/pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de", size = 2567509 },
+    { url = "https://files.pythonhosted.org/packages/c0/98/2c7d727079b6be1aba82d195767d35fcc2d32204c7a5820f822df5330152/pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84", size = 2254791 },
+    { url = "https://files.pythonhosted.org/packages/eb/38/998b04cc6f474e78b563716b20eecf42a2fa16a84589d23c8898e64b0ffd/pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b", size = 3150854 },
+    { url = "https://files.pythonhosted.org/packages/13/8e/be23a96292113c6cb26b2aa3c8b3681ec62b44ed5c2bd0b258bd59503d3c/pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003", size = 2982369 },
+    { url = "https://files.pythonhosted.org/packages/97/8a/3db4eaabb7a2ae8203cd3a332a005e4aba00067fc514aaaf3e9721be31f1/pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2", size = 4333703 },
+    { url = "https://files.pythonhosted.org/packages/28/ac/629ffc84ff67b9228fe87a97272ab125bbd4dc462745f35f192d37b822f1/pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a", size = 4412550 },
+    { url = "https://files.pythonhosted.org/packages/d6/07/a505921d36bb2df6868806eaf56ef58699c16c388e378b0dcdb6e5b2fb36/pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8", size = 4461038 },
+    { url = "https://files.pythonhosted.org/packages/d6/b9/fb620dd47fc7cc9678af8f8bd8c772034ca4977237049287e99dda360b66/pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8", size = 2253197 },
+    { url = "https://files.pythonhosted.org/packages/df/86/25dde85c06c89d7fc5db17940f07aae0a56ac69aa9ccb5eb0f09798862a8/pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904", size = 2572169 },
+    { url = "https://files.pythonhosted.org/packages/51/85/9c33f2517add612e17f3381aee7c4072779130c634921a756c97bc29fb49/pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3", size = 2256828 },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/d5/e5aeee5387091148a19e1145f63606619cb5f20b83fccb63efae6474e7b2/pyparsing-3.2.0.tar.gz", hash = "sha256:cbf74e27246d595d9a74b186b810f6fbb86726dbf3b9532efb343f6d7294fe9c", size = 920984 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/ec/2eb3cd785efd67806c46c13a17339708ddc346cbb684eade7a6e6f79536a/pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84", size = 106921 },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
+[[package]]
+name = "pytz"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
+]
+
+[[package]]
+name = "scipy"
+version = "1.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/11/4d44a1f274e002784e4dbdb81e0ea96d2de2d1045b2132d5af62cc31fd28/scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417", size = 58620554 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/04/2bdacc8ac6387b15db6faa40295f8bd25eccf33f1f13e68a72dc3c60a99e/scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d", size = 39128781 },
+    { url = "https://files.pythonhosted.org/packages/c8/53/35b4d41f5fd42f5781dbd0dd6c05d35ba8aa75c84ecddc7d44756cd8da2e/scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07", size = 29939542 },
+    { url = "https://files.pythonhosted.org/packages/66/67/6ef192e0e4d77b20cc33a01e743b00bc9e68fb83b88e06e636d2619a8767/scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5", size = 23148375 },
+    { url = "https://files.pythonhosted.org/packages/f6/32/3a6dedd51d68eb7b8e7dc7947d5d841bcb699f1bf4463639554986f4d782/scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc", size = 25578573 },
+    { url = "https://files.pythonhosted.org/packages/f0/5a/efa92a58dc3a2898705f1dc9dbaf390ca7d4fba26d6ab8cfffb0c72f656f/scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310", size = 35319299 },
+    { url = "https://files.pythonhosted.org/packages/8e/ee/8a26858ca517e9c64f84b4c7734b89bda8e63bec85c3d2f432d225bb1886/scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066", size = 40849331 },
+    { url = "https://files.pythonhosted.org/packages/a5/cd/06f72bc9187840f1c99e1a8750aad4216fc7dfdd7df46e6280add14b4822/scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1", size = 42544049 },
+    { url = "https://files.pythonhosted.org/packages/aa/7d/43ab67228ef98c6b5dd42ab386eae2d7877036970a0d7e3dd3eb47a0d530/scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f", size = 44521212 },
+    { url = "https://files.pythonhosted.org/packages/50/ef/ac98346db016ff18a6ad7626a35808f37074d25796fd0234c2bb0ed1e054/scipy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1729560c906963fc8389f6aac023739ff3983e727b1a4d87696b7bf108316a79", size = 39091068 },
+    { url = "https://files.pythonhosted.org/packages/b9/cc/70948fe9f393b911b4251e96b55bbdeaa8cca41f37c26fd1df0232933b9e/scipy-1.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:4079b90df244709e675cdc8b93bfd8a395d59af40b72e339c2287c91860deb8e", size = 29875417 },
+    { url = "https://files.pythonhosted.org/packages/3b/2e/35f549b7d231c1c9f9639f9ef49b815d816bf54dd050da5da1c11517a218/scipy-1.14.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf28db0f24a38b2a0ca33a85a54852586e43cf6fd876365c86e0657cfe7d73", size = 23084508 },
+    { url = "https://files.pythonhosted.org/packages/3f/d6/b028e3f3e59fae61fb8c0f450db732c43dd1d836223a589a8be9f6377203/scipy-1.14.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0c2f95de3b04e26f5f3ad5bb05e74ba7f68b837133a4492414b3afd79dfe540e", size = 25503364 },
+    { url = "https://files.pythonhosted.org/packages/a7/2f/6c142b352ac15967744d62b165537a965e95d557085db4beab2a11f7943b/scipy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b99722ea48b7ea25e8e015e8341ae74624f72e5f21fc2abd45f3a93266de4c5d", size = 35292639 },
+    { url = "https://files.pythonhosted.org/packages/56/46/2449e6e51e0d7c3575f289f6acb7f828938eaab8874dbccfeb0cd2b71a27/scipy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5149e3fd2d686e42144a093b206aef01932a0059c2a33ddfa67f5f035bdfe13e", size = 40798288 },
+    { url = "https://files.pythonhosted.org/packages/32/cd/9d86f7ed7f4497c9fd3e39f8918dd93d9f647ba80d7e34e4946c0c2d1a7c/scipy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4f5a7c49323533f9103d4dacf4e4f07078f360743dec7f7596949149efeec06", size = 42524647 },
+    { url = "https://files.pythonhosted.org/packages/f5/1b/6ee032251bf4cdb0cc50059374e86a9f076308c1512b61c4e003e241efb7/scipy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:baff393942b550823bfce952bb62270ee17504d02a1801d7fd0719534dfb9c84", size = 44469524 },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
+]
+
+[[package]]
+name = "tzdata"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 },
+]
Author	SHA1	Message	Date
Niccolo Borgioli	84e32bfaea	remove print	2024-12-08 21:37:22 +01:00
Niccolo Borgioli	0ba1f371ed	2024	2024-12-08 21:36:04 +01:00
Niccolo Borgioli	9ef0275a61	old stuff	2024-12-08 21:34:32 +01:00
Niccolo Borgioli	f1755e2bd3	day 2	2023-12-04 21:08:43 +01:00
Niccolo Borgioli	406b6fd197	remove type module	2023-12-02 00:28:26 +01:00
Niccolo Borgioli	91b75011c1	2023 01 ts	2023-12-02 00:28:10 +01:00
Niccolo Borgioli	416700e310	ts import dir	2023-12-02 00:28:00 +01:00
Niccolo Borgioli	40e3c65a5b	readme	2023-11-29 16:02:54 +01:00
Niccolo Borgioli	58df0a8bbe	add ts	2023-11-29 15:57:17 +01:00
Niccolo Borgioli	4a876daa71	refactor	2023-11-19 16:51:29 +01:00
Niccolo Borgioli	2b5a930d3d	template	2023-11-19 16:51:08 +01:00
Niccolo Borgioli	9923bbe321	day 2	2023-11-19 16:44:12 +01:00
Niccolo Borgioli	796033f6b3	day one improvements	2023-11-18 18:00:01 +01:00
Niccolo Borgioli	ad6ddf4f75	benchmarks	2023-11-18 17:52:07 +01:00
Niccolo Borgioli	eb723f5112	hygen rust	2023-11-18 17:06:39 +01:00
Niccolo Borgioli	3af5af2461	add rust	2023-11-18 16:45:50 +01:00