more progress.

over 40 stars!

2015/NOTES.md

@@ -0,0 +1,4 @@
+
+07 requires some type of tree traversal that I don't know.
+08 requires text processing that is beyond me right now
+09 requires tree traversal and tsp solution.

2015/src/bin/2015_05b.rs

@@ -69,3 +69,4 @@ fn main() {
     println!("Found {num_lines} good passwords.");
 
 }
+// 51

2015/src/bin/2015_07a.rs

@@ -0,0 +1,99 @@
+/// Actions in the processor
+#[derive(Debug)]
+enum Actions {
+    NOT { a: String, z: String },
+    OR { a: String, b: String, z: String },
+    AND { a: String, b: String, z: String },
+    RSHIFT { a: String, d: u32, z: String },
+    LSHIFT { a: String, d: u32, z: String },
+    Connection { a: String, z: String }
+}
+
+struct Wire {
+    pub connections: Vec<Actions>
+}
+
+fn identify_wires(input: &str) -> Vec<String> {
+    let mut working = vec![];
+
+    for line in input.lines() {
+        println!("Identifying wires in [[{line}]]");
+    }
+
+    working
+}
+
+fn parse_instruction(input: &str) -> Option<Actions> {
+    let parts : Vec<_> = input.split_whitespace().collect();
+
+    match parts.len() {
+        3 => {
+            Some(Actions::Connection { a: parts[0].to_string(), z: parts[2].to_string() })
+        },
+        4 => {
+            // NOT
+            match parts[0] {
+                "NOT" => {
+                    Some(Actions::NOT { a: parts[1].to_string(), z: parts[3].to_string()} )                },
+                _ => {
+                    println!("UNHANDLED 4 PART -> {input}");
+                    Some(Actions::Connection { a: "__".to_string(), z: "__".to_string() })
+                }
+            }
+        }
+        5 => {
+            match parts[1] {
+                "RSHIFT" => {
+                    Some(Actions::RSHIFT {
+                        a: parts[0].to_string(),
+                        d: parts[2].parse::<u32>().unwrap(),
+                        z: parts[4].to_string(),
+                    })
+                },
+                "LSHIFT" => {
+                    Some(Actions::LSHIFT {
+                        a: parts[0].to_string(),
+                        d: parts[2].parse::<u32>().unwrap(),
+                        z: parts[4].to_string()
+                    })
+                },
+                "AND" => {
+                    Some(Actions::AND {
+                        a: parts[0].to_string(),
+                        b: parts[2].to_string(),
+                        z: parts[4].to_string(),
+                    })
+                },
+                "OR" => {
+                    Some(Actions::OR {
+                        a: parts[0].to_string(),
+                        b: parts[2].to_string(),
+                        z: parts[4].to_string(),
+                    })
+                },
+                _ => {
+                    println!("UNHANDLED 5 PART -> {input}");
+                    None
+                }
+            }
+        },
+        _ => {
+            println!("Unhandled {} part -> {input}", parts.len());
+            None
+        }
+    }
+}
+
+use core::read_data;
+
+fn main() {
+    let binding = read_data("2015_07_data.txt");
+    let lines = binding.lines();
+
+    for line in lines {
+        let parsed = parse_instruction(line);
+        if parsed.is_some() {
+            println!("PARSED [[{line}]] into [[{parsed:?}]]");
+        }
+    }
+}

2015/src/bin/2015_07a_CHATGPT.rs

@@ -0,0 +1,87 @@
+use std::collections::HashMap;
+use core::read_data;
+
+#[derive(Debug, Clone)]
+enum Expr {
+    Value(u16),
+    Wire(String),
+    And(Box<Expr>, Box<Expr>),
+    Or(Box<Expr>, Box<Expr>),
+    LShift(Box<Expr>, u8),
+    RShift(Box<Expr>, u8),
+    Not(Box<Expr>),
+}
+
+fn parse_expr(token: &str) -> Expr {
+    if let Ok(num) = token.parse::<u16>() {
+        Expr::Value(num)
+    } else {
+        Expr::Wire(token.to_string())
+    }
+}
+
+fn parse_line(line: &str) -> (String, Expr) {
+    let parts: Vec<&str> = line.split(" -> ").collect();
+    let expr_str = parts[0];
+    let target = parts[1].to_string();
+
+    let tokens: Vec<&str> = expr_str.split_whitespace().collect();
+
+    let expr = match tokens.as_slice() {
+        [a] => parse_expr(a),
+        ["NOT", a] => Expr::Not(Box::new(parse_expr(a))),
+        [a, "AND", b] => Expr::And(Box::new(parse_expr(a)), Box::new(parse_expr(b))),
+        [a, "OR", b] => Expr::Or(Box::new(parse_expr(a)), Box::new(parse_expr(b))),
+        [a, "LSHIFT", n] => Expr::LShift(Box::new(parse_expr(a)), n.parse().unwrap()),
+        [a, "RSHIFT", n] => Expr::RShift(Box::new(parse_expr(a)), n.parse().unwrap()),
+        _ => panic!("Unrecognized expression: {}", expr_str),
+    };
+
+    (target, expr)
+}
+
+fn eval(
+    expr: &Expr,
+    circuit: &HashMap<String, Expr>,
+    cache: &mut HashMap<String, u16>,
+) -> u16 {
+    match expr {
+        Expr::Value(v) => *v,
+        Expr::Wire(w) => {
+            if let Some(&v) = cache.get(w) {
+                return v;
+            }
+            let e = circuit.get(w).unwrap_or_else(|| panic!("Unknown wire {}", w));
+            let v = eval(e, circuit, cache);
+            cache.insert(w.clone(), v);
+            v
+        }
+        Expr::And(a, b) => eval(a, circuit, cache) & eval(b, circuit, cache),
+        Expr::Or(a, b) => eval(a, circuit, cache) | eval(b, circuit, cache),
+        Expr::LShift(a, n) => eval(a, circuit, cache) << n,
+        Expr::RShift(a, n) => eval(a, circuit, cache) >> n,
+        Expr::Not(a) => !eval(a, circuit, cache),
+    }
+}
+
+
+fn main() {
+    //let args: Vec<String> = env::args().collect();
+    //let filename = args.get(1).expect("Usage: day7 <input_file>");
+    //let input = fs::read_to_string(filename).expect("Failed to read file");
+
+    let binding = read_data("2015_07_data.txt");
+    let input = binding.to_string();
+
+    let mut circuit = HashMap::new();
+    for line in input.lines() {
+        let (target, expr) = parse_line(line);
+        println!("target -> {target}");
+        circuit.insert(target, expr);
+    }
+
+    let mut cache = HashMap::new();
+    let a_val = eval(&Expr::Wire("a".to_string()), &circuit, &mut cache);
+
+    println!("Signal on wire a: {}", a_val);
+}

2015/src/bin/2015_08a.rs

@@ -1,40 +1,55 @@
 use core::read_data;
 
+fn parsed_string(input: &str) -> String {
+    let mut output = String::new();
+    let mut chars = input.chars().peekable();
+
+    while let Some(char) = chars.next() {
+        match char {
+            '\\' => {
+                match chars.next() {
+                    Some('n') => output.push('\n'),
+                    Some('t') => output.push('\t'),
+                    Some('\\') => output.push('\\'),
+                    Some('"') => output.push('"'),
+                    Some('x') => {
+                        let hi = chars.next().unwrap();
+                        let lo = chars.next().unwrap();
+                        let value = u8::from_str_radix(&format!("{hi}{lo}"), 16).unwrap();
+                        output.push(value as char)
+                    }
+                    Some(other) => output.push(other),
+                    None => {}
+                }
+            }
+            '"' => {}
+            _ => output.push(char)
+        }
+    }
+    output
+}
+
 fn main() {
+    let mut char_count = 0;
+    let mut mem_count = 0;
+
     let binding = read_data("2015_08_data.txt");
     let lines = binding.lines();
     let binding = vec![
-        "\"\"",
+        r#""""#,
-        "\"abc\"",
+        r#""abc""#,
-        "\"abc\\\"abc\"",
+        r#""aaa\"aaa""#,
-        "\"\\x27\""
+        r#"\x27"#
     ].join("\n");
     let lines = binding.lines();
 
     for line in lines {
-        let mut num_bytes = 0;
+        let raw_size = line.len();
-        let mut num_chars = 0;
+        let parsed = parsed_string(line).len();
-        let mut next_char_to_watch = 0;
+        println!("||{line}|| -> raw: {raw_size} parsed: {parsed}");
-        let mut line_chars = line.chars();
+        char_count += parsed;
-
+        mem_count += raw_size;
-        for (current_index, current_char) in line_chars.clone().enumerate() {
-            if current_index > next_char_to_watch {
-                match current_char {
-                    '"' => {
-                        num_bytes += 1;
-                    },
-                    '\\' => {
-                        println!("Found slash at {current_index}");
-                        let x = line_chars.nth(current_index).unwrap();
-                        // println!("{}", line_chars.colle
-                    }
-                    _ => {
-                        num_bytes += 1;
-                        num_chars += 1;
-                    }
-                }
-            }
-        }
-        println!("[{line}] = B:{num_bytes} C:{num_chars}");
     }
-}
+    println!("{} - {} = {}", char_count, mem_count, 0);
+    println!("{}",  mem_count - char_count);
+}

2015/src/bin/2015_10a.rs

@@ -20,27 +20,22 @@
 // 5: 1321132132211331232123222113
 // 6: ...
 
-fn num_to_change(input: &str) -> usize {
+fn look_and_say(input: String) -> String {
-    let mut return_value = 0;
+    let mut working = String::new();
-    let mut last_char = '\0';
+    let mut chars = input.chars().peekable();
 
-    for (index, current_char) in input.chars().enumerate() {
+    while let Some(current) = chars.next() {
-        if index != 0 {
+        let mut count = 1;
-            if last_char != current_char {
+        while let Some(&next) = chars.peek() {
-                return_value = index;
+            if next == current {
-                break
+                count += 1;
+                chars.next();
+            } else {
+                break;
             }
         }
-        last_char = current_char
+        working.push_str(&format!("{}{}", count, current));
     }
-    return_value
-}
-
-fn look_and_say(input: &str) -> String {
-    let mut working = String::new();
-
-
-
     working
 }
 
@@ -49,22 +44,27 @@ fn main() {
         ("1", "11"),
         ("11", "21"),
         ("21", "1211"),
-//        ("1211", "111221"),
+        ("1211", "111221"),
-//        ("111221", "31221")
+        ("111221", "312211")
     ];
 
     for (input, output) in params {
-        let result = look_and_say(input);
+        let result = look_and_say(input.to_string());
         println!("**** {input} processed to {result} expecting {output}");
         assert_eq!(result, output);
     }
 
+    let mut working_input = "";
+    let mut working_output = "";
     // // puzzle time
-    // let mut current_input = "1113122113";
+    let mut current_input = String::from("1113122113");
-    // for _ in 0..40 {
+    let mut tmp_input = String::new();
-    //     let next_input = current_input.clone();
+
-    //     let next_output = look_and_say(next_input);
+    for _ in 0..40 {
-    //     current_input = next_output.as_str();
+        tmp_input = look_and_say(current_input.clone());
-    // }
+        println!("[[{current_input}]] became [[{tmp_input}]]");
-    // println!("final -> {current_input}");
+        current_input = tmp_input;
-}
+    }
+    println!("final -> {}", current_input.len());
+}
+// 360154

2015/src/bin/2015_10b.rs

@@ -0,0 +1,54 @@
+// Look-and-say sequences are generated iteratively, using the previous value as input for the next
+// step. For each step, take the previous value, and replace each run of digits (like 111) with the
+// number of digits (3) followed by the digit itself (1).
+//
+// For example:
+//
+// 1 becomes 11 (1 copy of digit 1).
+// 11 becomes 21 (2 copies of digit 1).
+// 21 becomes 1211 (one 2 followed by one 1).
+// 1211 becomes 111221 (one 1, one 2, and two 1s).
+// 111221 becomes 312211 (three 1s, two 2s, and one 1).
+// Starting with the digits in your puzzle input, apply this process 40 times. What is the length
+// of the result?
+//
+// Your puzzle input is 1113122113.
+// 1: 311311222113
+// 2: 13211321322113
+// 3: 1113122113121113222113
+// 4: 31131122211311133113322113
+// 5: 1321132132211331232123222113
+// 6: ...
+
+fn look_and_say(input: String) -> String {
+    let mut working = String::new();
+    let mut chars = input.chars().peekable();
+
+    while let Some(current) = chars.next() {
+        let mut count = 1;
+        while let Some(&next) = chars.peek() {
+            if next == current {
+                count += 1;
+                chars.next();
+            } else {
+                break;
+            }
+        }
+        working.push_str(&format!("{}{}", count, current));
+    }
+    working
+}
+
+fn main() {
+    // // puzzle time
+    let mut current_input = String::from("1113122113");
+    let mut tmp_input = String::new();
+
+    for _ in 0..50 {
+        tmp_input = look_and_say(current_input.clone());
+        // println!("[[{current_input}]] became [[{tmp_input}]]");
+        current_input = tmp_input;
+    }
+    println!("final -> {}", current_input.len());
+}
+// 5103798

2015/src/bin/2015_11a.rs

@@ -0,0 +1,34 @@
+fn includes_straight(input: &str) -> bool {
+    true
+}
+
+fn excludes_forbidden(input: &str) -> bool {
+    !(
+        input.contains('i') ||
+        input.contains('o') ||
+        input.contains('l')
+    )
+}
+
+fn includes_pair(input: &str) -> bool {
+    let mut chars = input.chars().peekable();
+    while let Some(next) = chars.next() {
+
+    }
+
+    false
+}
+
+fn find_next_password(input: &str) -> String {}
+
+
+fn main() {
+    let params = vec![
+        ("abcdefgh", "abcdffaa"),
+        ("ghijklmn", "ghjaabcc")
+    ];
+
+    for (input, output) in params {
+        assert_eq!(find_next_password(input), output.to_string());
+    }
+}

2015/src/bin/2015_14a.rs

@@ -22,10 +22,37 @@
 // Given the descriptions of each reindeer (in your puzzle input), after exactly 2503 seconds, what
 // distance has the winning reindeer traveled?
 
-fn tick_world() {
+struct Reindeer {
+    pub name: String,
+    pub is_flying: bool,
+    pub speed: u32,
+    pub duration: u32,
+    pub stop_time: u32,
+    pub next_change: u32
+}
 
+impl Reindeer {
+    /// Tick the reindeer telling it what time the world thinks it is.
+    pub fn tick(&mut self, world_time: u32) {
+        
+    }
+}
+
+fn tick_world() {
 }
 
 fn main() {
-
+    let reindeer = vec![
+        Reindeer {
+            name: "Vixen".to_string(),
+            is_flying: false,
+            speed: 19,
+            duration: 7,
+            stop_time: 124,
+            next_change: 0,
+        },
+        Reindeer {},
+        Reindeer {},
+        Reindeer {}
+    ];
 }

2015/src/bin/2015_16a.rs

@@ -0,0 +1,134 @@
+use core::read_data;
+
+#[derive(Debug)]
+struct AuntSue {
+    pub id: i32,
+    pub children: i32,
+    pub cats: i32,
+    pub samoyeds: i32,
+    pub pomeranians: i32,
+    pub akitas: i32,
+    pub vizslas: i32,
+    pub goldfish: i32,
+    pub trees: i32,
+    pub cars: i32,
+    pub perfumes: i32
+}
+
+impl Default for AuntSue {
+    fn default() -> Self {
+        AuntSue {
+            id: -1,
+            children: -1,
+            cats: -1,
+            samoyeds: -1,
+            pomeranians: -1,
+            akitas: -1,
+            vizslas: -1,
+            goldfish: -1,
+            trees: -1,
+            cars: -1,
+            perfumes: -1,
+        }
+    }
+}
+
+fn parse_aunt(input: &str) -> AuntSue {
+    let mut working_sue = AuntSue::default();
+    let (sue_id, balance) = input.split_once(':').unwrap();
+    let (_, sue_id) = sue_id.trim().split_once(' ').unwrap();
+    // println!("SUE ID = [[{sue_id}]]");
+    let sue_id = sue_id.trim().parse::<i32>().unwrap();
+    working_sue.id = sue_id;
+    // println!("PARSING AUNT [[{input}]] / {sue_id}");
+    let sues_quirks = balance.split(", ");
+
+    for quirk in sues_quirks {
+        let (quirk_type, quirk_count) = quirk.trim().split_once(':').unwrap();
+        let quirk_count = quirk_count.trim().parse::<i32>().unwrap();
+        // println!("Sues Quirk is [[{quirk_type}]] with [[{quirk_count}]] instances.");
+        match quirk_type {
+            "vizslas" => {
+                working_sue.vizslas = quirk_count;
+            },
+            "perfumes" => {
+                working_sue.perfumes = quirk_count;
+            },
+            "akitas" => {
+                working_sue.akitas = quirk_count;
+            },
+            "cars" => {
+                working_sue.cars = quirk_count;
+            },
+            "trees" => {
+                working_sue.trees = quirk_count;
+            },
+            "cats" => {
+                working_sue.cats = quirk_count;
+            },
+            "goldfish" => {
+                working_sue.goldfish = quirk_count;
+            },
+            "pomeranians" => {
+                working_sue.pomeranians = quirk_count;
+            },
+            "samoyeds" => {
+                working_sue.samoyeds = quirk_count;
+            },
+            "children" => {
+                working_sue.children = quirk_count;
+            },
+            _ => {
+                println!("UNKNOWN TYPE OF QUIRK -> {quirk_type}");
+            }
+        }
+    }
+
+    // println!("Aunt Sue ID = {}")
+    // println!("** Aunt Done ** -> {working_sue:?}");
+    working_sue
+}
+
+fn is_the_sue_were_looking_for(input: &AuntSue) -> bool {
+    let target_sue= AuntSue {
+        id: 0,
+        children: 3,
+        cats: 7,
+        samoyeds: 2,
+        pomeranians: 3,
+        akitas: 0,
+        vizslas: 0,
+        goldfish: 5,
+        trees: 3,
+        cars: 2,
+        perfumes: 1,
+    };
+
+    let mut num_matches = 0;
+    if target_sue.children == input.children { num_matches += 1; };
+    if target_sue.cars == input.cats { num_matches += 1; }
+    if target_sue.samoyeds == input.samoyeds { num_matches += 1; };
+    if target_sue.pomeranians == input.pomeranians { num_matches += 1 };
+    if target_sue.akitas == input.akitas { num_matches += 1; };
+    if target_sue.vizslas == input.vizslas { num_matches += 1; };
+    if target_sue.goldfish == input.goldfish { num_matches += 1; };
+    if target_sue.trees == input.trees { num_matches += 1; };
+    if target_sue.cars == input.cars { num_matches += 1; };
+    if target_sue.perfumes == input.perfumes { num_matches += 1; };
+
+    num_matches == 3
+}
+
+fn main() {
+    let binding = read_data("2015_16_data.txt");
+    let lines = binding.lines();
+
+    for line in lines {
+        let parsed_aunt = parse_aunt(line);
+        if is_the_sue_were_looking_for(&parsed_aunt) {
+            println!("Aunt Sue {} is the aunt we want.", parsed_aunt.id);
+            break;
+        }
+    }
+}
+// 103

2015/src/bin/2015_16b.rs

@@ -0,0 +1,133 @@
+use core::read_data;
+
+#[derive(Debug)]
+struct AuntSue {
+    pub id: i32,
+    pub children: i32,
+    pub cats: i32,
+    pub samoyeds: i32,
+    pub pomeranians: i32,
+    pub akitas: i32,
+    pub vizslas: i32,
+    pub goldfish: i32,
+    pub trees: i32,
+    pub cars: i32,
+    pub perfumes: i32
+}
+
+impl Default for AuntSue {
+    fn default() -> Self {
+        AuntSue {
+            id: -1,
+            children: -1,
+            cats: -1,
+            samoyeds: -1,
+            pomeranians: -1,
+            akitas: -1,
+            vizslas: -1,
+            goldfish: -1,
+            trees: -1,
+            cars: -1,
+            perfumes: -1,
+        }
+    }
+}
+
+fn parse_aunt(input: &str) -> AuntSue {
+    let mut working_sue = AuntSue::default();
+    let (sue_id, balance) = input.split_once(':').unwrap();
+    let (_, sue_id) = sue_id.trim().split_once(' ').unwrap();
+    let sue_id = sue_id.trim().parse::<i32>().unwrap();
+    working_sue.id = sue_id;
+    // println!("PARSING AUNT [[{input}]] / {sue_id}");
+    let sues_quirks = balance.split(", ");
+
+    for quirk in sues_quirks {
+        let (quirk_type, quirk_count) = quirk.trim().split_once(':').unwrap();
+        let quirk_count = quirk_count.trim().parse::<i32>().unwrap();
+        // println!("Sues Quirk is [[{quirk_type}]] with [[{quirk_count}]] instances.");
+        match quirk_type {
+            "vizslas" => {
+                working_sue.vizslas = quirk_count;
+            },
+            "perfumes" => {
+                working_sue.perfumes = quirk_count;
+            },
+            "akitas" => {
+                working_sue.akitas = quirk_count;
+            },
+            "cars" => {
+                working_sue.cars = quirk_count;
+            },
+            "trees" => {
+                working_sue.trees = quirk_count;
+            },
+            "cats" => {
+                working_sue.cats = quirk_count;
+            },
+            "goldfish" => {
+                working_sue.goldfish = quirk_count;
+            },
+            "pomeranians" => {
+                working_sue.pomeranians = quirk_count;
+            },
+            "samoyeds" => {
+                working_sue.samoyeds = quirk_count;
+            },
+            "children" => {
+                working_sue.children = quirk_count;
+            },
+            _ => {
+                unreachable!("UNKNOWN TYPE OF QUIRK -> {}", quirk_type);
+            }
+        }
+    }
+
+    // println!("Aunt Sue ID = {}")
+    // println!("** Aunt Done ** -> {working_sue:?}");
+    working_sue
+}
+
+fn is_the_sue_were_looking_for(input: &AuntSue) -> bool {
+    let target_sue= AuntSue {
+        id: 0,
+        children: 3,
+        cats: 7,
+        samoyeds: 2,
+        pomeranians: 3,
+        akitas: 0,
+        vizslas: 0,
+        goldfish: 5,
+        trees: 3,
+        cars: 2,
+        perfumes: 1,
+    };
+
+    let mut num_matches = 0;
+    if target_sue.children == input.children { num_matches += 1; };
+    if target_sue.cats < input.cats && input.cats > -1 { num_matches += 1; }
+    if target_sue.samoyeds == input.samoyeds { num_matches += 1; };
+    if target_sue.pomeranians > input.pomeranians && input.pomeranians > -1 { num_matches += 1 };
+    if target_sue.akitas == input.akitas { num_matches += 1; };
+    if target_sue.vizslas == input.vizslas { num_matches += 1; };
+    if target_sue.goldfish > input.goldfish && input.goldfish > -1 { num_matches += 1; };
+    if target_sue.trees < input.trees && input.trees > -1 { num_matches += 1; };
+    if target_sue.cars == input.cars { num_matches += 1; };
+    if target_sue.perfumes == input.perfumes { num_matches += 1; };
+
+    num_matches == 3
+}
+
+fn main() {
+    let binding = read_data("2015_16_data.txt");
+    let lines = binding.lines();
+
+    for line in lines {
+        let parsed_aunt = parse_aunt(line);
+        if is_the_sue_were_looking_for(&parsed_aunt) {
+            println!("Aunt Sue {} is the aunt we want.", parsed_aunt.id);
+            break;
+        }
+    }
+}
+// 405

2015/src/bin/2015_18a.rs

@@ -0,0 +1,9 @@
+// this is the game of life.
+
+fn tick_world(input: &mut [bool; 100*100]) {
+
+}
+
+fn main() {
+    let mut world = [true; 100*100];
+}

2015/src/bin/2015_20a.rs

@@ -0,0 +1,3 @@
+
+
+fn main() {}

2015/src/bin/2015_23a.rs

@@ -0,0 +1,108 @@
+use core::read_data;
+
+#[derive(Default)]
+struct Computer {
+    pub a: u32,
+    pub b: u32,
+    pub pc: i32,
+}
+
+impl Computer {
+    fn dump(&self) {
+        println!("DUMPING COMPUTER");
+        println!("A: {}\tB: {}\tPC: {}",
+            self.a, self.b, self.pc
+        );
+    }
+}
+
+fn main() {
+    let mut computer = Computer::default();
+    let binding = read_data("2015_23_data.txt");
+    let lines = binding.lines();
+    for (index, line) in lines.enumerate() {
+        println!("Line {index} = [[{line}]]");
+        let (instruction, params) = line.split_once(" ").unwrap();
+        match instruction {
+            "inc" => {
+                match params.trim().chars().next().unwrap() {
+                    'a' => {
+                        computer.a += 1;
+                    },
+                    'b' => {
+                        computer.b += 1;
+                    },
+                    _ => { unreachable!("Invalid Register"); }
+                }
+            },
+            "tpl" => {
+                match params.trim().chars().next().unwrap() {
+                    'a' => {
+                        computer.a = computer.a * 3;
+                    },
+                    'b' => {
+                        computer.b = computer.b * 3;
+                    },
+                    _ => { unreachable!("Invalid Register") }
+                }
+            },
+            "hlf" => {
+                println!("HLF");
+                match params.trim().chars().next().unwrap() {
+                    'a' => {
+                        computer.a = computer.a / 2;
+                    }
+                    'b' => {
+                        computer.b = computer.b / 2;
+                    }
+                    _ => { unreachable!("Invalid Register"); }
+                }
+            },
+            "jmp" => {
+                println!("JMP Parse from [[{params}]]");
+                let offset = params.trim().parse::<i32>().unwrap();
+                computer.pc += offset;
+            },
+            "jie" => {
+                let (register, offset) = params.trim().split_once(' ').unwrap();
+                let offset = offset.parse::<i32>().unwrap();
+                match register.trim().chars().next().unwrap() {
+                    'a' => {
+                        if computer.a.is_multiple_of(2) {
+                            computer.pc += offset;
+                        }
+                    },
+                    'b' => {
+                        if computer.b.is_multiple_of(2) {
+                            computer.pc += offset;
+                        }
+                    },
+                    _ => { unreachable!("Invalid Register"); }
+                }
+            },
+            "jio" => {
+                let (register, offset) = params.trim().split_once(' ').unwrap();
+                let offset = offset.parse::<i32>().unwrap();
+                match register.trim().chars().next().unwrap() {
+                    'a' => {
+                        if !computer.a.is_multiple_of(2) {
+                            computer.pc += offset;
+                        }
+                    },
+                    'b' => {
+                        if !computer.b.is_multiple_of(2) {
+                            computer.pc += offset;
+                        }
+                    },
+                    _ => { unreachable!("Invalid Register"); }
+                }            },
+            _ => {
+                println!("Unhandled -> {instruction}");
+            }
+        }
+        computer.dump();
+    }
+
+    println!("Program loaded...");
+    computer.dump();
+}

2016/src/bin/2016_05b.rs

@@ -1,15 +1,31 @@
 use std::io::{stdout, Write};
 use md5::{Digest, Md5};
 
+fn has_8_chars(input: &Vec<char>) -> bool {
+    let mut num_spaces = 0;
+    for ch in input {
+        if *ch == ' ' { num_spaces += 1 }
+    }
+    num_spaces == 0
+}
+
+fn display_current_password(input: &Vec<char>) {
+    print!("\x1b[2K\rPassword: ");
+    for char in input {
+        if *char == ' ' { print!("_"); } else { print!("{}", char) };
+    }
+}
+
 fn main() {
     let input = "wtnhxymk";
     let mut password = vec![' '; 8];
+    let mut last_password_displayed = password.clone();
 
     for index in 2231253..=u32::MAX {
         let to_hash = format!("{}{}", input, index);
         let as_hash = format!("{:x}", Md5::digest(to_hash.as_bytes()));
         if as_hash.starts_with("00000") {
-            println!("Found hash with {index} -> {as_hash}");
+            // println!("Found hash with {index} -> {as_hash}");
             let ( sixth,balance ) = as_hash.as_str().split_at(5).1.split_at(1);
             let ( seventh, _) = balance.split_at(1);
             stdout().flush().unwrap();
@@ -17,8 +33,15 @@ fn main() {
             if index_for_new_char < 9 && password[index_for_new_char as usize] == ' ' {
                 password[index_for_new_char as usize] = seventh.parse().unwrap();
             }
-            println!("Index for new char = {index_for_new_char} / Password [{password:?}] / Seventh {seventh}");            // bail out if we have 8 characters
+            let mut to_disp = String::new();
-
+            for char in &password {
+                to_disp.push(*char);
+            }
+            if password != last_password_displayed {
+                last_password_displayed = password.clone();
+                display_current_password(&last_password_displayed);
+            }
+            if has_8_chars(&password.clone()) { break }
         }
     }
     println!("\nPassword is [{password:?}]");

2016/src/bin/2016_07a.rs

@@ -17,11 +17,42 @@
 // larger string).
 // How many IPs in your puzzle input support TLS?
 
-fn has_tls(input: &str) -> bool {
+use core::read_data;
-    true
+fn has_abba(input: &str) -> bool {
+    let chars: Vec<char> = input.chars().collect();
+
+    for i in 0..chars.len().saturating_sub(3) {
+        if chars[i] != chars[i + 1] &&
+            chars[i] == chars[i + 3] &&
+            chars[i + 1] == chars[i + 2] {
+            return true;
+        }
+    }
+    false
+}
+
+fn extract_hypernet(input: &str) -> (String, String) {
+    let mut payload = String::new();
+    let mut real_balance = String::from(input);
+    while real_balance.contains('[') {
+        let (prefix, balance) = real_balance.split_once('[').unwrap();
+        let (tmp, t_balance) = balance.split_once(']').unwrap();
+        payload = format!("{}{}", payload, tmp.to_string());
+        real_balance = format!("{}{}", prefix, t_balance);
+        // extract the text between the '[' and ']' characters
+    }
+    (real_balance, payload.to_string())
+}
+
+fn has_tls(address: &str, hypernet: &str) -> bool {
+    let abba = has_abba(address);
+    let noabba = !has_abba(hypernet);
+    println!("[{address}] ABBA: {abba} [{hypernet}] NOABBA: {noabba}");
+    abba && noabba
 }
 
 fn main() {
+    let mut num_good = 0;
     let params = vec![
         ("abba[mnop]qrst", true),
         ("abcd[bddb]xyyx", false),
@@ -30,6 +61,23 @@ fn main() {
     ];
 
     for (input, expected) in params {
-        assert_eq!(has_tls(input), expected)
+        println!("------------------Testing [[{input}]]");
+        let (address, hypernet) = extract_hypernet(input);
+        println!("[[{input}]] = ADD: {address} HN: {hypernet}");
+        assert_eq!(has_tls(address.as_str(), hypernet.as_str()), expected)
     }
+
+    let binding = read_data("2016_07_data.txt");
+    let lines = binding.lines();
+    for line in lines {
+        let (address, hypernet) = extract_hypernet(line);
+        println!("Processing ||||{line}||||  ->  {}/{}", address, hypernet);
+        if has_tls(address.as_str(), hypernet.as_str()) {
+            num_good += 1;
+        }
+    }
+    println!("Found {num_good} good addresses.");
 }
+
+
+// 132 too high

2016/src/bin/2016_08a.rs

@@ -0,0 +1,111 @@
+const SCREEN_COLS: usize = 50;
+const SCREEN_ROWS: usize = 6;
+const SCREEN_SIZE: usize = SCREEN_COLS * SCREEN_ROWS;
+
+#[derive(Debug, Copy, Clone)]
+enum Actions {
+    Rect(u32, u32),
+    RotateRow(u32, u32),
+    RotateColumn(u32, u32)
+}
+
+impl Actions {
+    // rotate a column 1 time.
+    fn rotate_column(&self, column_index: u32, target: &mut [bool; SCREEN_SIZE]) {
+        let first_value = target[column_index as usize];
+        for index in (SCREEN_COLS..0).rev() {
+            let offset = index as u32 * SCREEN_COLS as u32 + column_index;
+            println!("index = {index} offset = {offset}");
+        }
+    }
+
+    // rotate a row 1 time.
+    fn rotate_row(&self, row_index: u32, target: &mut [bool; SCREEN_SIZE]) {
+        for index in (SCREEN_ROWS..0).rev() {
+           let offset = index as u32 * SCREEN_COLS as u32 + index;
+            println!("index = {index} offset = {offset}");
+        }
+    }
+
+    pub fn apply(&self, target: &mut [bool; SCREEN_SIZE]) {
+        match self {
+            Actions::Rect(x, y) => {
+                // println!("Draw box sized {x}x{y}");
+                for row in 0..*y {
+                    for column in 0..*x {
+                        let offset = row * SCREEN_COLS as u32 + column;
+                        // println!("Setting {row}x{column}");
+                        target[offset as usize] = true;
+                    }
+                }
+            }
+            Actions::RotateRow(row_to_rotate, distance_to_rotate) => {
+                let actual_rotate = distance_to_rotate % 50;
+                println!("Rotate Row {row_to_rotate} by {distance_to_rotate} ({actual_rotate})");
+                for _ in 0..*distance_to_rotate {
+                    self.rotate_row(*row_to_rotate, target)
+                }
+            }
+            Actions::RotateColumn(column_to_rotate, distance_to_rotate) => {
+                let actual_rotate = distance_to_rotate % 6;
+                println!("Rotate Column {column_to_rotate} by {distance_to_rotate} ({actual_rotate})");
+                for _ in 0..*distance_to_rotate {
+                       self.rotate_column(*column_to_rotate, target)
+                }
+            }
+        }
+    }
+
+    pub fn parse(input: &str) -> Self {
+        let (command, params) = input.split_once(' ').unwrap();
+
+        match command {
+            "rect" => {
+                let (xs, ys) = params.trim().split_once('x').unwrap();
+                let x = xs.parse::<u32>().unwrap();
+                let y = ys.parse::<u32>().unwrap();
+                Actions::Rect(x, y)
+            },
+            "rotate" => {
+                let (direction, distance) = params.trim().split_once(' ').unwrap();
+                let (axis_stub, distance_to_rotate_s) = params.trim().split_once(" by ").unwrap();
+                let (_, axis_to_rotate_s) = axis_stub.split_once('=').unwrap();
+                let distance_to_rotate = distance_to_rotate_s.parse::<u32>().unwrap();
+                let axis_to_rotate = axis_to_rotate_s.parse::<u32>().unwrap();
+                Actions::RotateColumn(axis_to_rotate, distance_to_rotate)
+            }
+            _ => {
+                unreachable!("Invalid command -> [[{input}]]");
+            }
+        }
+    }
+}
+
+
+fn dump_screen(to_display: &[bool; SCREEN_SIZE]) {
+    for row in 0..SCREEN_ROWS {
+        for column in 0..SCREEN_COLS {
+            let offset = row * SCREEN_COLS + column;
+            // println!("Rendering offset {offset}");
+            print!("{}", if to_display[offset] { '#' } else { ' ' });
+        }
+        println!();
+    }
+}
+
+fn main() {
+    let mut screen_space:[bool; SCREEN_SIZE] = [false; SCREEN_SIZE];
+    let directions = vec![
+        "rect 3x2",
+        "rotate column x=1 by 1",
+        "rotate row y=0 by 4",
+        "rotate column x=1 by 1"
+    ];
+
+    for direction in directions {
+        let parsed = Actions::parse(direction);
+        parsed.apply(&mut screen_space);
+        println!("[[{direction}]] -> [[{parsed:?}]]");
+        dump_screen(&screen_space);
+    }
+}

2016/src/bin/2016_09a.rs

@@ -0,0 +1,3 @@
+fn main() {
+
+}

2020/src/bin/2020_01a.rs

@@ -4,8 +4,6 @@ fn main() {
     let binding = read_data("2020_01_data.txt");
     let lines = binding.lines();
     let mut numbers = vec![];
-    let mut left = 0;
-    let mut right = 0;
 
     for line in lines {
         numbers.push(line.parse::<u32>().unwrap());
@@ -21,4 +19,4 @@ fn main() {
         }
     }
 }
-// 972576
+// 972576

2020/src/bin/2020_03a.rs

@@ -0,0 +1,45 @@
+fn line_to_vec(input: &str) -> Vec<bool> {
+    input.chars()
+        .map(|x| {
+            match x { '.' => { false }, '#' => { true }, _ => { unreachable!("Invalid input -> [{x}]")} }
+        }).collect::<Vec<_>>()
+}
+
+use core::read_data;
+
+fn main() {
+    let input = "..##.......\n#...#...#..\n.#....#..#.\n..#.#...#.#\n.#...##..#.\n..#.##.....\n.#.#.#....#\n.#........#\n#.##...#...\n#...##....#\n.#..#...#.#";
+
+    let binding = read_data("2020_03_data.txt");
+    let input = binding.lines();
+
+    let mut world = vec![];
+
+    for line in input {
+        world.push(line_to_vec(line));
+        println!("[[{line}]] became [[{:?}]]", line_to_vec(line));
+    }
+
+    let mut current_x = 0;
+    let mut current_y = 0;
+    let mut num_hits = 0;
+
+    for current_row in world {
+        println!("Starting at {current_x}x{current_y}");
+
+        // <wherever i am horizontally> % <known data>
+        let offset = current_x % current_row.len();
+        if current_row[offset] {
+            println!("hit a tree");
+            num_hits += 1;
+        } else {
+            println!("missed the tree");
+        }
+
+        // finally move for the next row
+        current_x += 3;
+        current_y += 1;
+    }
+    println!("Finished at {current_x}x{current_y} with {num_hits} hits.");
+}
+// 280

2020/src/bin/2020_03b.rs

@@ -0,0 +1,50 @@
+use core::read_data;
+
+fn line_to_vec(input: &str) -> Vec<bool> {
+    input.chars()
+        .map(|x| {
+            match x { '.' => { false }, '#' => { true }, _ => { unreachable!("Invalid input -> [{x}]")} }
+        }).collect::<Vec<_>>()
+}
+
+fn count_hits(world: &Vec<Vec<bool>>, slope: (u32, u32)) -> u32 {
+    let mut num_hits = 0;
+    let mut current_x = 0;
+    let mut current_y = 0;
+
+    for current_row in world {
+        let offset = current_x as usize % current_row.len();
+        if current_row[offset] {
+            num_hits += 1;
+        }
+
+        current_x += slope.0;
+        current_y += slope.1;
+    }
+
+    num_hits
+}
+
+fn main() {
+    let binding = read_data("2020_03_data.txt");
+    let input = binding.lines();
+    let mut world = vec![];
+
+    for line in input {
+        world.push(line_to_vec(line));
+    }
+
+    let params = vec![
+        (1,1), (3,1), (5,1), (7,1), (1,2)
+    ];
+
+    let mut running_product = 1u64;
+
+    for (x_slope, y_slope) in params {
+        let num_hits = count_hits(&world, (x_slope, y_slope));
+        println!("Counted {} hits for {}x{}", num_hits, x_slope, y_slope);
+        running_product = running_product * num_hits as u64;
+    }
+    println!("Ended with {running_product}");
+}
+// 9582212640 to high

2020/src/bin/2020_04a.rs

@@ -0,0 +1,78 @@
+use core::read_data;
+
+#[derive(Debug)]
+struct Passport {
+    pub byr: i32,
+    pub iyr: i32,
+    pub eyr: i32,
+    pub hgt: i32,
+    pub hcl: String,
+    pub ecl: String,
+    pub pid: String,
+    pub cid: String
+}
+
+impl Passport {
+    pub fn valid(&self) -> bool {
+        self.byr > 0 &&
+            !self.hcl.is_empty() &&
+            !self.pid.is_empty() &&
+            !self.ecl.is_empty() &&
+            self.iyr > 0 &&
+            self.eyr > 0 &&
+            self.hgt > 0
+    }
+}
+
+impl Default for Passport {
+    fn default() -> Self {
+        Passport {
+            byr: -1,
+            iyr: -1,
+            eyr: -1,
+            hgt: -1,
+            hcl: "".to_string(),
+            ecl: "".to_string(),
+            pid: "".to_string(),
+            cid: "".to_string(),
+        }
+    }
+}
+
+fn parse_record(input: &str) -> Passport {
+    let mut working = Passport::default();
+
+    let parts: Vec<_> = input.split_whitespace().collect();
+    for part in parts {
+        let (key, value) = part.split_once(':').unwrap();
+        match key {
+            "pid" => working.pid = value.parse().unwrap(),
+            "hgt" => working.hgt = value.parse().unwrap_or(1),
+            "byr" => working.byr = value.parse().unwrap(),
+            "hcl" => working.hcl = value.to_string(),
+            "ecl" => working.ecl = value.to_string(),
+            "iyr" => working.iyr = value.parse().unwrap(),
+            "eyr" => working.eyr = value.parse().unwrap(),
+            "cid" => working.cid = value.parse().unwrap(),
+            _ => { unreachable!("Unrecognized key -> [[{key}]] VALUE -> [[{value}]]"); }
+        }
+    }
+
+    working
+}
+
+fn main() {
+    let binding = read_data("2020_04_data.txt");
+    let lines: Vec<_> = binding.split("\n\n").collect();
+    let mut num_valid = 0;
+
+    // println!("Records:");
+    for line in lines {
+        let parsed = parse_record(line);
+        if parsed.valid() { num_valid += 1; }
+        // println!("[[{parsed:?}]]");
+    }
+    println!("Found {num_valid} valid passports.");
+}
+// 151 is too low
+// 254

2020/src/bin/2020_04b.rs

@@ -0,0 +1,123 @@
+use core::read_data;
+
+#[derive(Debug)]
+struct Passport {
+    pub byr: i32,
+    pub iyr: i32,
+    pub eyr: i32,
+    pub hgt: i32,
+    pub hcl: String,
+    pub ecl: String,
+    pub pid: String,
+    pub cid: String
+}
+
+impl Default for Passport {
+    fn default() -> Self {
+        Passport {
+            byr: -1,
+            iyr: -1,
+            eyr: -1,
+            hgt: -1,
+            hcl: "".to_string(),
+            ecl: "".to_string(),
+            pid: "".to_string(),
+            cid: "".to_string(),
+        }
+    }
+}
+
+impl Passport {
+    fn byr_valid(&self) -> bool {
+        self.byr <= 2002 && self.byr >= 1920
+    }
+    fn iyr_valid(&self) -> bool {
+        self.iyr <= 2020 && self.iyr >= 2010
+    }
+
+    pub fn valid(&self) -> bool {
+        self.byr_valid() &&
+            !self.hcl.is_empty() &&
+            !self.pid.is_empty() &&
+            !self.ecl.is_empty() &&
+            self.iyr_valid() &&
+            self.eyr > 0 &&
+            self.hgt > 0
+    }
+
+    pub fn from(input: &str) -> Self {
+        let mut working = Passport::default();
+
+        let parts: Vec<_> = input.split_whitespace().collect();
+        for part in parts {
+            let (key, value) = part.split_once(':').unwrap();
+            match key {
+                "ecl" => { Passport::parse_ecl(&mut working, value) }
+                "cid" => { /* ignored */ }
+                "pid" => { Passport::parse_pid(&mut working, value) }
+                    _ => { unreachable!("Not handled -> [[{key}]] value -> [[{value}]]"); }
+            }
+        }
+
+        working
+    }
+
+    fn parse_ecl( passport: &mut Passport, input: &str) {
+        passport.ecl = input.to_string()
+    }
+
+    fn ecl_valid(&self) -> bool {
+        self.ecl == "amb" ||
+            self.ecl == "blu" ||
+            self.ecl == "brn" ||
+            self.ecl == "gry" ||
+            self.ecl == "grn" ||
+            self.ecl == "hzl" ||
+            self.ecl == "oth"
+    }
+
+    fn parse_pid( passport: &mut Passport,  input: &str) {
+        passport.pid = input.to_string();
+    }
+
+    fn pid_valid(&self) -> bool {
+
+    }
+
+}
+
+fn parse_record(input: &str) -> Passport {
+    let mut working = Passport::default();
+
+    let parts: Vec<_> = input.split_whitespace().collect();
+    for part in parts {
+        let (key, value) = part.split_once(':').unwrap();
+        match key {
+            "pid" => working.pid = value.parse().unwrap(),
+            "hgt" => working.hgt = value.parse().unwrap_or(1),
+            "byr" => working.byr = value.parse().unwrap(),
+            "hcl" => working.hcl = value.to_string(),
+            "ecl" => working.ecl = value.to_string(),
+            "iyr" => working.iyr = value.parse().unwrap(),
+            "eyr" => working.eyr = value.parse().unwrap(),
+            "cid" => working.cid = value.parse().unwrap(),
+            _ => { unreachable!("Unrecognized key -> [[{key}]] VALUE -> [[{value}]]"); }
+        }
+    }
+
+    working
+}
+
+fn main() {
+    let binding = read_data("2020_04_data.txt");
+    let lines: Vec<_> = binding.split("\n\n").collect();
+    let mut num_valid = 0;
+
+    // println!("Records:");
+    for line in lines {
+        let parsed = parse_record(line);
+        if parsed.valid() { num_valid += 1; }
+        // println!("[[{parsed:?}]]");
+    }
+    println!("Found {num_valid} valid passports.");
+}

2020/src/bin/2020_1b.rs

@@ -0,0 +1,24 @@
+use core::read_data;
+
+fn main() {
+    let binding = read_data("2020_01_data.txt");
+    let lines = binding.lines();
+    let mut numbers = vec![];
+
+    for line in lines {
+        numbers.push(line.parse::<u32>().unwrap());
+    }
+
+    for first in numbers.clone() {
+        for second in numbers.clone() {
+            for third in numbers.clone() {
+                if first + second + third == 2020 {
+                    println!("{} {} {}", first, second, third);
+                    println!("{}", first * second * third);
+                    break
+                }
+            }
+        }
+    }
+}
+//  199300880

2024/Cargo.toml

@@ -5,3 +5,4 @@ edition = "2024"
 
 [dependencies]
 core = { path = "../core" }
+regex = "1.11.2"

2024/src/bin/2024_02b.rs

@@ -0,0 +1,107 @@
+// now exclude 1 bad report and see if its still valid
+
+use std::{env, fs};
+use core::read_data;
+
+fn min_max(num1: u32, num2: u32) -> (u32, u32) {
+    (num1.min(num2), num1.max(num2))
+}
+
+fn in_range(min: u32, max: u32, target: u32) -> bool {
+    min <= target && target <= max
+}
+
+fn parse_numbers(s: &str) -> Vec<u32> {
+    s.split_whitespace()                 // split on whitespace
+        .filter_map(|num| num.parse::<u32>().ok()) // try to parse each piece
+        .collect()
+}
+fn is_safe(report: &str) -> bool {
+    let mut is_safe = true;
+
+    let numbers = parse_numbers(report);
+    println!("*******************************************************\nnumbers: {:?}", numbers);
+    let mut is_increasing = numbers[0] < numbers[1];
+
+    for index in 0..numbers.len() - 1 {
+        let first = numbers[index];
+        let second = numbers[index + 1];
+
+        if first.abs_diff(second) > 3 || first.abs_diff(second) < 1 {
+            is_safe = false;
+        }
+        if is_increasing && first >= second  {
+            is_safe = false;
+        }
+        if !is_increasing && first <= second {
+            is_safe = false;
+        }
+    }
+
+    is_safe
+}
+
+fn is_safe_numbers(numbers: &[u32]) -> bool {
+    if numbers.len() < 2 {
+        return true;
+    }
+
+    let is_increasing = numbers[0] < numbers[1];
+
+    for i in 0..numbers.len() - 1 {
+        let first = numbers[i];
+        let second = numbers[i + 1];
+        let diff = first.abs_diff(second);
+
+        if diff < 1 || diff > 3 {
+            return false;
+        }
+        if is_increasing && first >= second {
+            return false;
+        }
+        if !is_increasing && first <= second {
+            return false;
+        }
+    }
+
+    true
+}
+
+fn is_safe_less_one(report: &str) -> bool {
+    let numbers = parse_numbers(report);
+
+    // Already safe?
+    if is_safe_numbers(&numbers) {
+        return true;
+    }
+
+    // Try removing each element
+    for i in 0..numbers.len() {
+        let mut variant = numbers.clone();
+        variant.remove(i);
+        if is_safe_numbers(&variant) {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn main() {
+    let input_file = read_data("2024_02_data.txt");
+    let mut num_safe = 0;
+    // let input_file = "7 6 4 2 1\n1 2 7 8 9\n9 7 6 2 1\n1 3 2 4 5\n8 6 4 4 1\n1 3 6 7 9";
+
+    let reports = input_file.lines();
+    for report in reports {
+        let is_safe = is_safe_less_one(report);
+        println!("Handling report of {report} -> Safe: {}",is_safe);
+        if is_safe {
+            num_safe += 1;
+        }
+    }
+    println!("Found {num_safe} safe readings.");
+}
+// 644
+// Chatgpt used to understand why my previous code didnt work.  i was counting errors, not removing
+// an element and testing again.

2024/src/bin/2024_03a.rs

@@ -0,0 +1,19 @@
+use core::read_data;
+use regex::Regex;
+
+fn main() {
+    let binding = read_data("2024_03_data.txt");
+
+    // use Regex to pull out the parts we want...
+    let re = Regex::new(r"mul\((\d{1,3}),(\d{1,3})\)").unwrap();
+
+    let sum: u32 = re.find_iter(&binding)
+        .filter_map(|m| {
+            let caps = re.captures(m.as_str()).unwrap();
+            let x: u32 = caps.get(1).unwrap().as_str().parse().ok().unwrap();
+            let y: u32 = caps.get(2).unwrap().as_str().parse().ok().unwrap();
+            Some(x * y)
+        }).sum();
+
+    println!("Sum = {sum}");
+}

2024/src/bin/2024_04a.rs

@@ -0,0 +1,31 @@
+// load data to array.
+// look for 'xmas'
+
+fn main() {
+    let params = "MMMSXXMASM\nMSAMXMSMSA\nAMXSXMAAMM\nMSAMASMSMX\nXMASAMXAMM\nXXAMMXXAMA\nSMSMSASXSS\nSAXAMASAAA\nMAMMMXMMMM\nMXMXAXMASX";
+    let mut running_total = 0;
+    let params_chars: Vec<char> = params.chars().collect();
+
+    let lines = params.lines();
+    let lines_num = lines.clone().count();
+    let line_len = lines.last().unwrap().len();
+    for column_index in 0..line_len {
+        for row_index in 0..lines_num {
+            let current_offset = column_index * line_len + row_index;
+            let this_box: [char; 9] = [
+                params_chars[current_offset - line_len - 1],
+                params_chars[current_offset - line_len],
+                params_chars[current_offset - line_len + 1],
+                params_chars[current_offset - 1],
+                params_chars[current_offset],
+                params_chars[current_offset + 1],
+                params_chars[current_offset + line_len - 1],
+                params_chars[current_offset + line_len],
+                params_chars[current_offset + line_len + 1]
+            ];
+            let new_total = 0; // find_xmas(this_box, column_index, row_index);
+            running_total += new_total;
+            println!("Checking for XMAS at {}x{} -> {}", column_index, row_index, new_total);
+        }
+    }
+}

2024/src/bin/2024_04a_chatgpt.rs

@@ -0,0 +1,110 @@
+use std::io::{self, Read};
+
+fn main() {
+    // Read the whole input
+    let mut s = String::new();
+    io::stdin().read_to_string(&mut s).unwrap();
+
+    // Build grid of chars (skip any completely empty lines)
+    let grid: Vec<Vec<char>> = s
+        .lines()
+        .filter(|ln| !ln.trim().is_empty())
+        .map(|ln| ln.chars().collect())
+        .collect();
+
+    let h = grid.len();
+    let w = grid.get(0).map(|r| r.len()).unwrap_or(0);
+    if h == 0 || w == 0 {
+        println!("0");
+        return;
+    }
+
+    let word: [char; 4] = ['X', 'M', 'A', 'S'];
+    let dirs: [(isize, isize); 8] = [
+        (-1, -1), (-1, 0), (-1, 1),
+        ( 0, -1),          ( 0, 1),
+        ( 1, -1), ( 1, 0), ( 1, 1),
+    ];
+
+    let mut count = 0usize;
+
+    for y in 0..h {
+        for x in 0..w {
+            if grid[y][x] != 'X' { continue; }
+            for (dy, dx) in dirs {
+                let mut ok = true;
+                for k in 0..word.len() {
+                    let ny = y as isize + dy * k as isize;
+                    let nx = x as isize + dx * k as isize;
+                    if ny < 0 || nx < 0 || ny >= h as isize || nx >= w as isize {
+                        ok = false;
+                        break;
+                    }
+                    if grid[ny as usize][nx as usize] != word[k] {
+                        ok = false;
+                        break;
+                    }
+                }
+                if ok { count += 1; }
+            }
+        }
+    }
+
+    println!("{}", count);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn example_counts_18() {
+        let input = "\
+MMMSXXMASM
+MSAMXMSMSA
+AMXSXMAAMM
+MSAMASMSMX
+XMASAMXAMM
+XXAMMXXAMA
+SMSMSASXSS
+SAXAMASAAA
+MAMMMXMMMM
+MXMXAXMASX
+";
+        // Re-run main logic here for the sample
+        let grid: Vec<Vec<char>> = input
+            .lines()
+            .filter(|ln| !ln.trim().is_empty())
+            .map(|ln| ln.chars().collect())
+            .collect();
+        let h = grid.len();
+        let w = grid[0].len();
+        let word: [char; 4] = ['X', 'M', 'A', 'S'];
+        let dirs: [(isize, isize); 8] = [
+            (-1, -1), (-1, 0), (-1, 1),
+            ( 0, -1),          ( 0, 1),
+            ( 1, -1), ( 1, 0), ( 1, 1),
+        ];
+        let mut count = 0usize;
+        for y in 0..h {
+            for x in 0..w {
+                if grid[y][x] != 'X' { continue; }
+                for (dy, dx) in dirs {
+                    let mut ok = true;
+                    for k in 0..word.len() {
+                        let ny = y as isize + dy * k as isize;
+                        let nx = x as isize + dx * k as isize;
+                        if ny < 0 || nx < 0 || ny >= h as isize || nx >= w as isize {
+                            ok = false; break;
+                        }
+                        if grid[ny as usize][nx as usize] != word[k] {
+                            ok = false; break;
+                        }
+                    }
+                    if ok { count += 1; }
+                }
+            }
+        }
+        assert_eq!(count, 18);
+    }
+}

Cargo.lock

@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "aoc2015"
 version = "0.1.0"
@@ -72,6 +81,7 @@ name = "aoc2024"
 version = "0.1.0"
 dependencies = [
  "core",
+ "regex",
 ]
 
 [[package]]
@@ -133,6 +143,41 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "regex"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+
 [[package]]
 name = "typenum"
 version = "1.18.0"

README

@@ -7,3 +7,17 @@ The content of this repo would violate the terms of the AOC project if it was in
  mentioned as not suitable for redistribution and as such, go away.
 
 Trevor maintains this for his own personal pleasure and reference.
+
+To Sept 9, 2025
+2015  16
+2016   8
+2017   3
+2018   2
+2019   2
+2020   6
+2021   1
+2022   5
+2023   1
+2024   3
+--------
+      47

data/2015_07_data.txt

@@ -0,0 +1,339 @@
+NOT dq -> dr
+kg OR kf -> kh
+ep OR eo -> eq
+44430 -> b
+NOT gs -> gt
+dd OR do -> dp
+eg AND ei -> ej
+y AND ae -> ag
+jx AND jz -> ka
+lf RSHIFT 2 -> lg
+z AND aa -> ac
+dy AND ej -> el
+bj OR bi -> bk
+kk RSHIFT 3 -> km
+NOT cn -> co
+gn AND gp -> gq
+cq AND cs -> ct
+eo LSHIFT 15 -> es
+lg OR lm -> ln
+dy OR ej -> ek
+NOT di -> dj
+1 AND fi -> fj
+kf LSHIFT 15 -> kj
+NOT jy -> jz
+NOT ft -> fu
+fs AND fu -> fv
+NOT hr -> hs
+ck OR cl -> cm
+jp RSHIFT 5 -> js
+iv OR jb -> jc
+is OR it -> iu
+ld OR le -> lf
+NOT fc -> fd
+NOT dm -> dn
+bn OR by -> bz
+aj AND al -> am
+cd LSHIFT 15 -> ch
+jp AND ka -> kc
+ci OR ct -> cu
+gv AND gx -> gy
+de AND dk -> dm
+x RSHIFT 5 -> aa
+et RSHIFT 2 -> eu
+x RSHIFT 1 -> aq
+ia OR ig -> ih
+bk LSHIFT 1 -> ce
+y OR ae -> af
+NOT ca -> cb
+e AND f -> h
+ia AND ig -> ii
+ck AND cl -> cn
+NOT jh -> ji
+z OR aa -> ab
+1 AND en -> eo
+ib AND ic -> ie
+NOT eh -> ei
+iy AND ja -> jb
+NOT bb -> bc
+ha OR gz -> hb
+1 AND cx -> cy
+NOT ax -> ay
+ev OR ew -> ex
+bn RSHIFT 2 -> bo
+er OR es -> et
+eu OR fa -> fb
+jp OR ka -> kb
+ea AND eb -> ed
+k AND m -> n
+et RSHIFT 3 -> ev
+et RSHIFT 5 -> ew
+hz RSHIFT 1 -> is
+ki OR kj -> kk
+NOT h -> i
+lv LSHIFT 15 -> lz
+as RSHIFT 1 -> bl
+hu LSHIFT 15 -> hy
+iw AND ix -> iz
+lf RSHIFT 1 -> ly
+fp OR fv -> fw
+1 AND am -> an
+ap LSHIFT 1 -> bj
+u LSHIFT 1 -> ao
+b RSHIFT 5 -> f
+jq AND jw -> jy
+iu RSHIFT 3 -> iw
+ih AND ij -> ik
+NOT iz -> ja
+de OR dk -> dl
+iu OR jf -> jg
+as AND bd -> bf
+b RSHIFT 3 -> e
+jq OR jw -> jx
+iv AND jb -> jd
+cg OR ch -> ci
+iu AND jf -> jh
+lx -> a
+1 AND cc -> cd
+ly OR lz -> ma
+NOT el -> em
+1 AND bh -> bi
+fb AND fd -> fe
+lf OR lq -> lr
+bn RSHIFT 3 -> bp
+bn AND by -> ca
+af AND ah -> ai
+cf LSHIFT 1 -> cz
+dw OR dx -> dy
+gj AND gu -> gw
+jg AND ji -> jj
+jr OR js -> jt
+bl OR bm -> bn
+gj RSHIFT 2 -> gk
+cj OR cp -> cq
+gj OR gu -> gv
+b OR n -> o
+o AND q -> r
+bi LSHIFT 15 -> bm
+dy RSHIFT 1 -> er
+cu AND cw -> cx
+iw OR ix -> iy
+hc OR hd -> he
+0 -> c
+db OR dc -> dd
+kk RSHIFT 2 -> kl
+eq LSHIFT 1 -> fk
+dz OR ef -> eg
+NOT ed -> ee
+lw OR lv -> lx
+fw AND fy -> fz
+dz AND ef -> eh
+jp RSHIFT 3 -> jr
+lg AND lm -> lo
+ci RSHIFT 2 -> cj
+be AND bg -> bh
+lc LSHIFT 1 -> lw
+hm AND ho -> hp
+jr AND js -> ju
+1 AND io -> ip
+cm AND co -> cp
+ib OR ic -> id
+NOT bf -> bg
+fo RSHIFT 5 -> fr
+ip LSHIFT 15 -> it
+jt AND jv -> jw
+jc AND je -> jf
+du OR dt -> dv
+NOT fx -> fy
+aw AND ay -> az
+ge LSHIFT 15 -> gi
+NOT ak -> al
+fm OR fn -> fo
+ff AND fh -> fi
+ci RSHIFT 5 -> cl
+cz OR cy -> da
+NOT ey -> ez
+NOT ju -> jv
+NOT ls -> lt
+kk AND kv -> kx
+NOT ii -> ij
+kl AND kr -> kt
+jk LSHIFT 15 -> jo
+e OR f -> g
+NOT bs -> bt
+hi AND hk -> hl
+hz OR ik -> il
+ek AND em -> en
+ao OR an -> ap
+dv LSHIFT 1 -> ep
+an LSHIFT 15 -> ar
+fo RSHIFT 1 -> gh
+NOT im -> in
+kk RSHIFT 1 -> ld
+hw LSHIFT 1 -> iq
+ec AND ee -> ef
+hb LSHIFT 1 -> hv
+kb AND kd -> ke
+x AND ai -> ak
+dd AND do -> dq
+aq OR ar -> as
+iq OR ip -> ir
+dl AND dn -> do
+iu RSHIFT 5 -> ix
+as OR bd -> be
+NOT go -> gp
+fk OR fj -> fl
+jm LSHIFT 1 -> kg
+NOT cv -> cw
+dp AND dr -> ds
+dt LSHIFT 15 -> dx
+et RSHIFT 1 -> fm
+dy RSHIFT 3 -> ea
+fp AND fv -> fx
+NOT p -> q
+dd RSHIFT 2 -> de
+eu AND fa -> fc
+ba AND bc -> bd
+dh AND dj -> dk
+lr AND lt -> lu
+he RSHIFT 1 -> hx
+ex AND ez -> fa
+df OR dg -> dh
+fj LSHIFT 15 -> fn
+NOT kx -> ky
+gk OR gq -> gr
+dy RSHIFT 2 -> dz
+gh OR gi -> gj
+lj AND ll -> lm
+x OR ai -> aj
+bz AND cb -> cc
+1 AND lu -> lv
+as RSHIFT 3 -> au
+ce OR cd -> cf
+il AND in -> io
+dd RSHIFT 1 -> dw
+NOT lo -> lp
+c LSHIFT 1 -> t
+dd RSHIFT 3 -> df
+dd RSHIFT 5 -> dg
+lh AND li -> lk
+lf RSHIFT 5 -> li
+dy RSHIFT 5 -> eb
+NOT kt -> ku
+at OR az -> ba
+x RSHIFT 3 -> z
+NOT lk -> ll
+lb OR la -> lc
+1 AND r -> s
+lh OR li -> lj
+ln AND lp -> lq
+kk RSHIFT 5 -> kn
+ea OR eb -> ec
+ci AND ct -> cv
+b RSHIFT 2 -> d
+jp RSHIFT 1 -> ki
+NOT cr -> cs
+NOT jd -> je
+jp RSHIFT 2 -> jq
+jn OR jo -> jp
+lf RSHIFT 3 -> lh
+1 AND ds -> dt
+lf AND lq -> ls
+la LSHIFT 15 -> le
+NOT fg -> fh
+at AND az -> bb
+au AND av -> ax
+kw AND ky -> kz
+v OR w -> x
+kk OR kv -> kw
+ks AND ku -> kv
+kh LSHIFT 1 -> lb
+1 AND kz -> la
+NOT kc -> kd
+x RSHIFT 2 -> y
+et OR fe -> ff
+et AND fe -> fg
+NOT ac -> ad
+jl OR jk -> jm
+1 AND jj -> jk
+bn RSHIFT 1 -> cg
+NOT kp -> kq
+ci RSHIFT 3 -> ck
+ev AND ew -> ey
+1 AND ke -> kf
+cj AND cp -> cr
+ir LSHIFT 1 -> jl
+NOT gw -> gx
+as RSHIFT 2 -> at
+iu RSHIFT 1 -> jn
+cy LSHIFT 15 -> dc
+hg OR hh -> hi
+ci RSHIFT 1 -> db
+au OR av -> aw
+km AND kn -> kp
+gj RSHIFT 1 -> hc
+iu RSHIFT 2 -> iv
+ab AND ad -> ae
+da LSHIFT 1 -> du
+NOT bw -> bx
+km OR kn -> ko
+ko AND kq -> kr
+bv AND bx -> by
+kl OR kr -> ks
+1 AND ht -> hu
+df AND dg -> di
+NOT ag -> ah
+d OR j -> k
+d AND j -> l
+b AND n -> p
+gf OR ge -> gg
+gg LSHIFT 1 -> ha
+bn RSHIFT 5 -> bq
+bo OR bu -> bv
+1 AND gy -> gz
+s LSHIFT 15 -> w
+NOT ie -> if
+as RSHIFT 5 -> av
+bo AND bu -> bw
+hz AND ik -> im
+bp AND bq -> bs
+b RSHIFT 1 -> v
+NOT l -> m
+bp OR bq -> br
+g AND i -> j
+br AND bt -> bu
+t OR s -> u
+hz RSHIFT 5 -> ic
+gk AND gq -> gs
+fl LSHIFT 1 -> gf
+he RSHIFT 3 -> hg
+gz LSHIFT 15 -> hd
+hf OR hl -> hm
+1 AND gd -> ge
+fo OR fz -> ga
+id AND if -> ig
+fo AND fz -> gb
+gr AND gt -> gu
+he OR hp -> hq
+fq AND fr -> ft
+ga AND gc -> gd
+fo RSHIFT 2 -> fp
+gl OR gm -> gn
+hg AND hh -> hj
+NOT hn -> ho
+gl AND gm -> go
+he RSHIFT 5 -> hh
+NOT gb -> gc
+hq AND hs -> ht
+hz RSHIFT 3 -> ib
+hz RSHIFT 2 -> ia
+fq OR fr -> fs
+hx OR hy -> hz
+he AND hp -> hr
+gj RSHIFT 5 -> gm
+hf AND hl -> hn
+hv OR hu -> hw
+NOT hj -> hk
+gj RSHIFT 3 -> gl
+fo RSHIFT 3 -> fq
+he RSHIFT 2 -> hf

data/2015_16_data.txt

@@ -0,0 +1,500 @@
+Sue 1: goldfish: 6, trees: 9, akitas: 0
+Sue 2: goldfish: 7, trees: 1, akitas: 0
+Sue 3: cars: 10, akitas: 6, perfumes: 7
+Sue 4: perfumes: 2, vizslas: 0, cars: 6
+Sue 5: goldfish: 1, trees: 3, perfumes: 10
+Sue 6: children: 9, vizslas: 7, cars: 9
+Sue 7: cars: 6, vizslas: 5, cats: 3
+Sue 8: akitas: 10, vizslas: 9, children: 3
+Sue 9: vizslas: 8, cats: 2, trees: 1
+Sue 10: perfumes: 10, trees: 6, cars: 4
+Sue 11: cars: 9, children: 1, cats: 1
+Sue 12: pomeranians: 4, akitas: 6, goldfish: 8
+Sue 13: cats: 10, children: 5, trees: 9
+Sue 14: perfumes: 8, vizslas: 3, samoyeds: 1
+Sue 15: vizslas: 2, perfumes: 8, trees: 3
+Sue 16: pomeranians: 10, trees: 9, samoyeds: 4
+Sue 17: akitas: 7, vizslas: 0, goldfish: 6
+Sue 18: trees: 5, vizslas: 9, cars: 0
+Sue 19: akitas: 3, goldfish: 9, trees: 10
+Sue 20: perfumes: 7, samoyeds: 3, vizslas: 10
+Sue 21: perfumes: 7, pomeranians: 10, akitas: 8
+Sue 22: vizslas: 6, trees: 8, akitas: 10
+Sue 23: goldfish: 0, trees: 4, children: 9
+Sue 24: goldfish: 7, pomeranians: 9, akitas: 4
+Sue 25: cars: 7, trees: 4, pomeranians: 4
+Sue 26: trees: 9, akitas: 9, pomeranians: 7
+Sue 27: samoyeds: 0, perfumes: 9, goldfish: 10
+Sue 28: cars: 5, trees: 7, vizslas: 1
+Sue 29: perfumes: 9, trees: 1, children: 6
+Sue 30: goldfish: 10, trees: 0, cars: 4
+Sue 31: akitas: 2, perfumes: 5, goldfish: 5
+Sue 32: goldfish: 0, akitas: 5, trees: 0
+Sue 33: vizslas: 2, akitas: 2, samoyeds: 3
+Sue 34: goldfish: 8, perfumes: 5, cars: 3
+Sue 35: akitas: 1, cats: 4, trees: 9
+Sue 36: cars: 4, vizslas: 4, goldfish: 7
+Sue 37: akitas: 5, perfumes: 7, trees: 3
+Sue 38: goldfish: 10, trees: 2, vizslas: 9
+Sue 39: goldfish: 4, pomeranians: 5, vizslas: 5
+Sue 40: perfumes: 5, samoyeds: 4, akitas: 6
+Sue 41: goldfish: 9, cars: 4, perfumes: 5
+Sue 42: trees: 6, pomeranians: 9, goldfish: 8
+Sue 43: perfumes: 7, pomeranians: 1, akitas: 2
+Sue 44: vizslas: 9, cars: 5, cats: 0
+Sue 45: akitas: 1, goldfish: 6, trees: 0
+Sue 46: akitas: 5, vizslas: 8, trees: 2
+Sue 47: trees: 9, akitas: 2, vizslas: 9
+Sue 48: goldfish: 10, trees: 5, akitas: 2
+Sue 49: cars: 7, vizslas: 2, perfumes: 6
+Sue 50: akitas: 5, goldfish: 6, perfumes: 0
+Sue 51: cars: 9, cats: 7, trees: 5
+Sue 52: akitas: 7, goldfish: 10, cars: 0
+Sue 53: cars: 10, cats: 4, perfumes: 2
+Sue 54: goldfish: 2, pomeranians: 5, perfumes: 10
+Sue 55: vizslas: 5, akitas: 4, cars: 8
+Sue 56: goldfish: 9, vizslas: 4, akitas: 5
+Sue 57: perfumes: 8, samoyeds: 7, cars: 9
+Sue 58: cars: 5, akitas: 7, perfumes: 8
+Sue 59: samoyeds: 8, cars: 10, vizslas: 10
+Sue 60: akitas: 6, samoyeds: 0, goldfish: 3
+Sue 61: trees: 8, pomeranians: 0, akitas: 2
+Sue 62: trees: 1, perfumes: 3, vizslas: 4
+Sue 63: vizslas: 6, samoyeds: 9, goldfish: 8
+Sue 64: goldfish: 7, trees: 6, vizslas: 3
+Sue 65: cars: 1, vizslas: 0, akitas: 6
+Sue 66: cats: 6, pomeranians: 4, cars: 9
+Sue 67: trees: 10, pomeranians: 7, samoyeds: 3
+Sue 68: pomeranians: 5, goldfish: 9, akitas: 1
+Sue 69: akitas: 1, vizslas: 0, trees: 9
+Sue 70: cats: 4, goldfish: 4, vizslas: 10
+Sue 71: vizslas: 7, perfumes: 7, trees: 8
+Sue 72: children: 2, vizslas: 9, cats: 3
+Sue 73: cars: 8, pomeranians: 0, perfumes: 6
+Sue 74: akitas: 1, pomeranians: 8, vizslas: 10
+Sue 75: vizslas: 5, perfumes: 5, cars: 7
+Sue 76: cars: 3, vizslas: 3, goldfish: 0
+Sue 77: akitas: 9, samoyeds: 1, pomeranians: 3
+Sue 78: trees: 0, vizslas: 0, akitas: 6
+Sue 79: pomeranians: 9, cars: 1, perfumes: 0
+Sue 80: perfumes: 10, trees: 1, cats: 0
+Sue 81: goldfish: 5, akitas: 9, trees: 0
+Sue 82: vizslas: 1, akitas: 6, children: 4
+Sue 83: samoyeds: 7, perfumes: 8, pomeranians: 4
+Sue 84: perfumes: 3, children: 3, cats: 7
+Sue 85: goldfish: 9, trees: 3, cars: 9
+Sue 86: cars: 0, perfumes: 9, vizslas: 0
+Sue 87: children: 3, trees: 4, akitas: 3
+Sue 88: trees: 1, samoyeds: 1, goldfish: 0
+Sue 89: akitas: 8, cars: 3, vizslas: 9
+Sue 90: pomeranians: 9, trees: 9, goldfish: 8
+Sue 91: goldfish: 7, trees: 10, children: 0
+Sue 92: cats: 9, cars: 7, perfumes: 7
+Sue 93: vizslas: 2, goldfish: 7, cats: 9
+Sue 94: akitas: 5, cars: 8, vizslas: 4
+Sue 95: goldfish: 7, vizslas: 1, perfumes: 2
+Sue 96: goldfish: 5, trees: 6, perfumes: 10
+Sue 97: trees: 0, perfumes: 7, cars: 0
+Sue 98: cars: 2, perfumes: 6, trees: 8
+Sue 99: trees: 10, children: 7, cats: 9
+Sue 100: samoyeds: 5, goldfish: 6, vizslas: 6
+Sue 101: cars: 10, perfumes: 9, vizslas: 3
+Sue 102: pomeranians: 6, trees: 1, samoyeds: 4
+Sue 103: cars: 2, perfumes: 1, goldfish: 5
+Sue 104: goldfish: 2, cars: 8, pomeranians: 2
+Sue 105: goldfish: 6, vizslas: 0, trees: 10
+Sue 106: trees: 10, akitas: 10, pomeranians: 0
+Sue 107: vizslas: 2, pomeranians: 10, trees: 3
+Sue 108: children: 3, vizslas: 8, akitas: 7
+Sue 109: perfumes: 2, akitas: 2, samoyeds: 3
+Sue 110: goldfish: 7, trees: 1, perfumes: 1
+Sue 111: akitas: 2, cars: 9, perfumes: 2
+Sue 112: children: 10, cars: 0, akitas: 3
+Sue 113: akitas: 9, vizslas: 4, children: 3
+Sue 114: pomeranians: 3, trees: 2, goldfish: 5
+Sue 115: perfumes: 8, cars: 6, trees: 0
+Sue 116: samoyeds: 6, children: 3, pomeranians: 1
+Sue 117: goldfish: 1, trees: 2, akitas: 1
+Sue 118: goldfish: 10, akitas: 10, samoyeds: 0
+Sue 119: vizslas: 10, perfumes: 6, cars: 0
+Sue 120: cars: 2, perfumes: 9, goldfish: 5
+Sue 121: vizslas: 2, trees: 2, cars: 6
+Sue 122: vizslas: 3, trees: 0, akitas: 2
+Sue 123: akitas: 5, samoyeds: 7, goldfish: 1
+Sue 124: goldfish: 8, samoyeds: 7, trees: 8
+Sue 125: trees: 3, goldfish: 8, perfumes: 5
+Sue 126: cats: 3, vizslas: 9, goldfish: 0
+Sue 127: pomeranians: 9, goldfish: 3, perfumes: 6
+Sue 128: vizslas: 4, cars: 8, goldfish: 5
+Sue 129: vizslas: 8, children: 5, perfumes: 8
+Sue 130: cars: 7, children: 7, cats: 3
+Sue 131: perfumes: 1, akitas: 8, vizslas: 9
+Sue 132: perfumes: 7, samoyeds: 10, pomeranians: 6
+Sue 133: cars: 5, perfumes: 3, goldfish: 7
+Sue 134: perfumes: 9, akitas: 2, cats: 3
+Sue 135: perfumes: 1, trees: 9, vizslas: 9
+Sue 136: akitas: 7, cars: 3, perfumes: 7
+Sue 137: vizslas: 9, goldfish: 8, cars: 5
+Sue 138: trees: 0, samoyeds: 1, cars: 3
+Sue 139: cars: 0, perfumes: 6, trees: 0
+Sue 140: pomeranians: 4, cars: 1, perfumes: 7
+Sue 141: vizslas: 10, akitas: 8, cats: 3
+Sue 142: trees: 1, cats: 6, vizslas: 5
+Sue 143: pomeranians: 9, cars: 7, perfumes: 9
+Sue 144: cars: 0, perfumes: 2, pomeranians: 1
+Sue 145: trees: 1, goldfish: 9, perfumes: 8
+Sue 146: cars: 8, children: 5, vizslas: 2
+Sue 147: perfumes: 2, goldfish: 5, cars: 0
+Sue 148: akitas: 2, perfumes: 7, pomeranians: 6
+Sue 149: goldfish: 8, cars: 0, trees: 1
+Sue 150: akitas: 6, perfumes: 5, trees: 0
+Sue 151: vizslas: 6, samoyeds: 8, akitas: 10
+Sue 152: trees: 7, akitas: 7, perfumes: 6
+Sue 153: goldfish: 9, cats: 9, cars: 3
+Sue 154: vizslas: 10, trees: 0, cars: 9
+Sue 155: perfumes: 3, children: 2, goldfish: 1
+Sue 156: goldfish: 7, perfumes: 5, akitas: 6
+Sue 157: cats: 10, trees: 1, goldfish: 0
+Sue 158: cats: 7, children: 7, vizslas: 6
+Sue 159: perfumes: 9, akitas: 0, cars: 0
+Sue 160: akitas: 3, goldfish: 10, pomeranians: 2
+Sue 161: goldfish: 10, cars: 6, perfumes: 3
+Sue 162: trees: 0, cars: 9, goldfish: 1
+Sue 163: cars: 8, perfumes: 9, vizslas: 5
+Sue 164: goldfish: 1, trees: 10, children: 6
+Sue 165: goldfish: 0, vizslas: 6, cars: 0
+Sue 166: akitas: 5, vizslas: 1, cars: 5
+Sue 167: vizslas: 1, samoyeds: 1, children: 4
+Sue 168: samoyeds: 7, vizslas: 7, akitas: 3
+Sue 169: goldfish: 3, cats: 9, trees: 2
+Sue 170: cars: 5, perfumes: 9, vizslas: 5
+Sue 171: goldfish: 7, cars: 6, perfumes: 10
+Sue 172: cats: 6, akitas: 1, children: 6
+Sue 173: cats: 4, goldfish: 1, children: 3
+Sue 174: cars: 2, pomeranians: 2, vizslas: 7
+Sue 175: trees: 0, children: 4, goldfish: 7
+Sue 176: children: 8, cars: 5, cats: 9
+Sue 177: pomeranians: 4, vizslas: 7, trees: 3
+Sue 178: vizslas: 6, perfumes: 10, akitas: 6
+Sue 179: cars: 4, akitas: 4, trees: 4
+Sue 180: akitas: 8, goldfish: 6, trees: 9
+Sue 181: perfumes: 3, vizslas: 10, cars: 3
+Sue 182: vizslas: 3, samoyeds: 3, goldfish: 7
+Sue 183: goldfish: 10, perfumes: 2, cats: 1
+Sue 184: goldfish: 5, trees: 1, perfumes: 1
+Sue 185: vizslas: 10, trees: 9, perfumes: 2
+Sue 186: goldfish: 6, perfumes: 9, trees: 1
+Sue 187: cars: 0, trees: 9, goldfish: 6
+Sue 188: cars: 0, trees: 1, vizslas: 9
+Sue 189: akitas: 7, vizslas: 2, trees: 0
+Sue 190: pomeranians: 5, perfumes: 8, akitas: 10
+Sue 191: vizslas: 5, akitas: 3, cats: 0
+Sue 192: children: 1, trees: 1, cars: 2
+Sue 193: cars: 3, goldfish: 9, trees: 2
+Sue 194: samoyeds: 3, akitas: 4, perfumes: 8
+Sue 195: trees: 1, vizslas: 8, akitas: 10
+Sue 196: akitas: 6, cars: 5, pomeranians: 0
+Sue 197: akitas: 5, vizslas: 5, cats: 1
+Sue 198: trees: 4, cars: 6, goldfish: 6
+Sue 199: cats: 7, cars: 5, goldfish: 6
+Sue 200: vizslas: 4, cats: 0, akitas: 9
+Sue 201: pomeranians: 1, perfumes: 4, children: 2
+Sue 202: cats: 1, perfumes: 4, vizslas: 3
+Sue 203: vizslas: 1, akitas: 9, children: 5
+Sue 204: perfumes: 8, cars: 7, trees: 4
+Sue 205: perfumes: 7, pomeranians: 5, cats: 9
+Sue 206: vizslas: 8, trees: 2, akitas: 2
+Sue 207: akitas: 6, vizslas: 2, perfumes: 10
+Sue 208: vizslas: 1, children: 7, akitas: 4
+Sue 209: perfumes: 4, trees: 2, children: 1
+Sue 210: goldfish: 0, vizslas: 2, samoyeds: 10
+Sue 211: cars: 8, perfumes: 3, trees: 1
+Sue 212: cars: 8, samoyeds: 5, pomeranians: 8
+Sue 213: akitas: 2, goldfish: 8, pomeranians: 2
+Sue 214: akitas: 6, pomeranians: 2, cars: 0
+Sue 215: trees: 10, pomeranians: 4, vizslas: 0
+Sue 216: perfumes: 0, cars: 8, trees: 0
+Sue 217: samoyeds: 8, akitas: 7, children: 10
+Sue 218: perfumes: 1, vizslas: 6, children: 0
+Sue 219: children: 1, goldfish: 4, trees: 1
+Sue 220: akitas: 10, goldfish: 10, trees: 5
+Sue 221: cars: 7, pomeranians: 6, perfumes: 3
+Sue 222: vizslas: 6, children: 0, akitas: 5
+Sue 223: perfumes: 9, cars: 1, trees: 6
+Sue 224: pomeranians: 1, trees: 0, vizslas: 0
+Sue 225: goldfish: 8, akitas: 4, perfumes: 10
+Sue 226: pomeranians: 7, cats: 7, children: 4
+Sue 227: trees: 0, akitas: 2, perfumes: 1
+Sue 228: vizslas: 6, cars: 10, perfumes: 9
+Sue 229: cars: 0, perfumes: 6, trees: 4
+Sue 230: pomeranians: 7, perfumes: 5, trees: 2
+Sue 231: goldfish: 9, cars: 6, trees: 7
+Sue 232: akitas: 1, vizslas: 5, cars: 3
+Sue 233: akitas: 7, samoyeds: 2, vizslas: 5
+Sue 234: akitas: 6, cats: 8, pomeranians: 0
+Sue 235: pomeranians: 5, akitas: 5, vizslas: 3
+Sue 236: goldfish: 5, trees: 6, akitas: 5
+Sue 237: goldfish: 9, perfumes: 5, cats: 5
+Sue 238: cats: 8, goldfish: 4, perfumes: 0
+Sue 239: samoyeds: 8, children: 6, pomeranians: 6
+Sue 240: akitas: 4, samoyeds: 10, trees: 8
+Sue 241: trees: 2, goldfish: 8, cars: 1
+Sue 242: perfumes: 2, cars: 0, akitas: 10
+Sue 243: pomeranians: 1, cars: 7, trees: 2
+Sue 244: trees: 9, vizslas: 2, akitas: 10
+Sue 245: cars: 9, pomeranians: 4, trees: 0
+Sue 246: cars: 9, pomeranians: 7, perfumes: 1
+Sue 247: trees: 0, goldfish: 1, akitas: 8
+Sue 248: vizslas: 1, cats: 4, akitas: 4
+Sue 249: cats: 6, children: 4, goldfish: 9
+Sue 250: vizslas: 1, cars: 10, samoyeds: 5
+Sue 251: cars: 0, goldfish: 1, vizslas: 7
+Sue 252: cars: 7, akitas: 9, vizslas: 10
+Sue 253: akitas: 7, vizslas: 2, perfumes: 5
+Sue 254: vizslas: 10, akitas: 5, samoyeds: 0
+Sue 255: pomeranians: 8, goldfish: 0, cats: 6
+Sue 256: cars: 10, goldfish: 8, vizslas: 9
+Sue 257: goldfish: 3, perfumes: 9, cats: 3
+Sue 258: trees: 6, goldfish: 6, cars: 6
+Sue 259: trees: 0, goldfish: 2, perfumes: 8
+Sue 260: trees: 5, akitas: 0, cars: 0
+Sue 261: pomeranians: 9, goldfish: 7, perfumes: 8
+Sue 262: perfumes: 8, vizslas: 6, goldfish: 2
+Sue 263: vizslas: 6, trees: 5, goldfish: 9
+Sue 264: vizslas: 4, perfumes: 7, cars: 9
+Sue 265: goldfish: 10, trees: 3, perfumes: 1
+Sue 266: trees: 10, akitas: 8, goldfish: 8
+Sue 267: goldfish: 4, trees: 0, samoyeds: 9
+Sue 268: vizslas: 1, trees: 0, goldfish: 8
+Sue 269: cars: 2, perfumes: 10, goldfish: 5
+Sue 270: perfumes: 7, cars: 2, vizslas: 1
+Sue 271: cars: 6, perfumes: 10, goldfish: 6
+Sue 272: samoyeds: 4, goldfish: 2, vizslas: 9
+Sue 273: perfumes: 4, goldfish: 4, vizslas: 1
+Sue 274: children: 4, cars: 4, perfumes: 3
+Sue 275: children: 8, vizslas: 3, trees: 2
+Sue 276: vizslas: 5, children: 7, perfumes: 3
+Sue 277: perfumes: 3, cats: 4, vizslas: 5
+Sue 278: cars: 1, samoyeds: 10, akitas: 2
+Sue 279: trees: 9, perfumes: 9, cars: 10
+Sue 280: vizslas: 5, trees: 0, perfumes: 6
+Sue 281: vizslas: 3, akitas: 10, pomeranians: 7
+Sue 282: trees: 1, children: 2, akitas: 8
+Sue 283: akitas: 9, goldfish: 6, cats: 5
+Sue 284: cars: 9, children: 10, pomeranians: 2
+Sue 285: pomeranians: 0, perfumes: 4, cars: 7
+Sue 286: perfumes: 0, vizslas: 10, akitas: 10
+Sue 287: cats: 2, perfumes: 3, trees: 5
+Sue 288: akitas: 9, vizslas: 8, samoyeds: 9
+Sue 289: perfumes: 6, children: 2, cars: 7
+Sue 290: akitas: 0, children: 5, cars: 5
+Sue 291: cars: 4, perfumes: 0, trees: 1
+Sue 292: cats: 0, cars: 8, perfumes: 6
+Sue 293: akitas: 9, cats: 5, children: 5
+Sue 294: akitas: 4, cars: 9, goldfish: 3
+Sue 295: cars: 2, akitas: 3, perfumes: 7
+Sue 296: perfumes: 4, cars: 7, goldfish: 10
+Sue 297: trees: 5, akitas: 8, vizslas: 1
+Sue 298: perfumes: 0, goldfish: 6, trees: 9
+Sue 299: perfumes: 6, samoyeds: 8, cars: 1
+Sue 300: goldfish: 10, perfumes: 4, akitas: 2
+Sue 301: cars: 3, trees: 0, goldfish: 8
+Sue 302: perfumes: 7, samoyeds: 2, vizslas: 7
+Sue 303: children: 10, goldfish: 7, perfumes: 2
+Sue 304: samoyeds: 8, vizslas: 2, cars: 1
+Sue 305: trees: 1, cats: 0, goldfish: 10
+Sue 306: trees: 4, perfumes: 2, cars: 7
+Sue 307: cars: 6, vizslas: 2, children: 6
+Sue 308: vizslas: 2, cars: 0, akitas: 7
+Sue 309: cars: 3, vizslas: 8, perfumes: 6
+Sue 310: goldfish: 7, perfumes: 7, vizslas: 3
+Sue 311: pomeranians: 10, trees: 2, cars: 0
+Sue 312: samoyeds: 2, vizslas: 9, akitas: 1
+Sue 313: cars: 4, pomeranians: 7, goldfish: 7
+Sue 314: akitas: 2, pomeranians: 9, samoyeds: 10
+Sue 315: akitas: 3, vizslas: 2, trees: 0
+Sue 316: cars: 0, perfumes: 4, pomeranians: 6
+Sue 317: akitas: 10, goldfish: 3, pomeranians: 7
+Sue 318: cars: 9, trees: 0, pomeranians: 9
+Sue 319: akitas: 3, vizslas: 7, children: 10
+Sue 320: vizslas: 0, akitas: 8, pomeranians: 4
+Sue 321: cars: 10, akitas: 9, vizslas: 3
+Sue 322: perfumes: 0, akitas: 8, vizslas: 6
+Sue 323: vizslas: 10, perfumes: 5, cars: 3
+Sue 324: akitas: 0, goldfish: 6, vizslas: 7
+Sue 325: perfumes: 9, vizslas: 5, pomeranians: 2
+Sue 326: vizslas: 6, goldfish: 10, pomeranians: 8
+Sue 327: vizslas: 10, cars: 1, akitas: 7
+Sue 328: trees: 1, perfumes: 10, cars: 10
+Sue 329: pomeranians: 5, samoyeds: 3, cars: 10
+Sue 330: akitas: 6, cars: 1, pomeranians: 4
+Sue 331: cars: 5, children: 2, trees: 0
+Sue 332: vizslas: 6, pomeranians: 1, perfumes: 0
+Sue 333: akitas: 7, trees: 1, cats: 9
+Sue 334: vizslas: 6, goldfish: 9, akitas: 7
+Sue 335: akitas: 3, samoyeds: 3, cars: 3
+Sue 336: samoyeds: 10, perfumes: 9, trees: 6
+Sue 337: vizslas: 2, cars: 9, akitas: 0
+Sue 338: akitas: 6, perfumes: 9, vizslas: 3
+Sue 339: cars: 3, samoyeds: 8, trees: 2
+Sue 340: cats: 7, perfumes: 8, cars: 9
+Sue 341: goldfish: 9, perfumes: 5, cars: 10
+Sue 342: trees: 0, akitas: 3, perfumes: 5
+Sue 343: perfumes: 2, children: 0, cars: 6
+Sue 344: goldfish: 8, trees: 8, perfumes: 0
+Sue 345: perfumes: 6, cars: 6, goldfish: 5
+Sue 346: vizslas: 8, trees: 1, cars: 6
+Sue 347: cars: 0, cats: 3, perfumes: 7
+Sue 348: children: 7, perfumes: 10, cars: 7
+Sue 349: pomeranians: 8, akitas: 5, children: 2
+Sue 350: perfumes: 9, pomeranians: 4, goldfish: 3
+Sue 351: perfumes: 8, pomeranians: 7, trees: 4
+Sue 352: samoyeds: 1, goldfish: 9, akitas: 8
+Sue 353: akitas: 6, goldfish: 10, vizslas: 8
+Sue 354: akitas: 7, cars: 2, goldfish: 6
+Sue 355: cars: 3, goldfish: 6, akitas: 5
+Sue 356: akitas: 2, goldfish: 9, pomeranians: 1
+Sue 357: goldfish: 10, cars: 6, pomeranians: 9
+Sue 358: trees: 0, children: 2, goldfish: 6
+Sue 359: samoyeds: 3, cars: 2, akitas: 4
+Sue 360: trees: 1, goldfish: 8, cars: 5
+Sue 361: akitas: 5, vizslas: 7, perfumes: 1
+Sue 362: cats: 5, vizslas: 9, children: 4
+Sue 363: goldfish: 9, perfumes: 3, vizslas: 9
+Sue 364: children: 7, samoyeds: 2, pomeranians: 10
+Sue 365: perfumes: 9, akitas: 10, pomeranians: 4
+Sue 366: cars: 10, trees: 3, cats: 4
+Sue 367: vizslas: 6, akitas: 10, perfumes: 5
+Sue 368: akitas: 9, vizslas: 9, children: 4
+Sue 369: goldfish: 8, trees: 2, perfumes: 5
+Sue 370: trees: 0, children: 4, cars: 8
+Sue 371: cats: 6, perfumes: 0, vizslas: 2
+Sue 372: akitas: 7, cars: 5, perfumes: 3
+Sue 373: cars: 0, perfumes: 4, pomeranians: 10
+Sue 374: akitas: 5, perfumes: 5, vizslas: 2
+Sue 375: goldfish: 7, trees: 10, pomeranians: 7
+Sue 376: cars: 8, trees: 1, pomeranians: 8
+Sue 377: cars: 0, akitas: 9, vizslas: 1
+Sue 378: akitas: 5, perfumes: 3, vizslas: 7
+Sue 379: trees: 2, goldfish: 8, pomeranians: 8
+Sue 380: akitas: 5, cars: 9, perfumes: 9
+Sue 381: cars: 2, perfumes: 6, trees: 3
+Sue 382: perfumes: 6, vizslas: 2, goldfish: 9
+Sue 383: akitas: 8, vizslas: 7, cats: 1
+Sue 384: akitas: 9, trees: 10, vizslas: 7
+Sue 385: cars: 0, perfumes: 7, vizslas: 2
+Sue 386: vizslas: 10, akitas: 4, perfumes: 9
+Sue 387: perfumes: 6, pomeranians: 5, samoyeds: 8
+Sue 388: vizslas: 10, trees: 9, goldfish: 9
+Sue 389: goldfish: 8, akitas: 4, perfumes: 10
+Sue 390: goldfish: 6, trees: 8, akitas: 1
+Sue 391: vizslas: 4, akitas: 10, goldfish: 7
+Sue 392: akitas: 1, vizslas: 6, samoyeds: 5
+Sue 393: trees: 6, cars: 3, akitas: 5
+Sue 394: goldfish: 9, trees: 3, cars: 5
+Sue 395: akitas: 6, samoyeds: 4, goldfish: 4
+Sue 396: akitas: 2, trees: 1, cats: 5
+Sue 397: cars: 0, children: 9, trees: 10
+Sue 398: pomeranians: 3, samoyeds: 9, goldfish: 10
+Sue 399: cars: 7, akitas: 4, goldfish: 8
+Sue 400: cars: 4, akitas: 5, vizslas: 4
+Sue 401: pomeranians: 5, akitas: 8, vizslas: 5
+Sue 402: cats: 7, cars: 6, goldfish: 6
+Sue 403: samoyeds: 8, perfumes: 4, cars: 5
+Sue 404: akitas: 10, goldfish: 4, trees: 2
+Sue 405: trees: 8, perfumes: 1, cars: 2
+Sue 406: trees: 0, perfumes: 9, pomeranians: 10
+Sue 407: perfumes: 4, trees: 7, goldfish: 3
+Sue 408: akitas: 1, perfumes: 3, cars: 5
+Sue 409: trees: 6, samoyeds: 3, cars: 9
+Sue 410: vizslas: 3, goldfish: 5, akitas: 7
+Sue 411: goldfish: 10, trees: 1, vizslas: 9
+Sue 412: cars: 0, akitas: 6, trees: 6
+Sue 413: goldfish: 7, trees: 0, cars: 3
+Sue 414: pomeranians: 10, samoyeds: 3, cars: 10
+Sue 415: perfumes: 6, trees: 9, cars: 4
+Sue 416: trees: 2, cars: 4, goldfish: 8
+Sue 417: goldfish: 2, cars: 9, cats: 5
+Sue 418: vizslas: 1, cars: 9, akitas: 0
+Sue 419: perfumes: 6, cats: 3, children: 9
+Sue 420: cats: 5, goldfish: 7, akitas: 9
+Sue 421: trees: 1, samoyeds: 6, pomeranians: 1
+Sue 422: trees: 10, goldfish: 6, children: 7
+Sue 423: cars: 8, goldfish: 7, vizslas: 3
+Sue 424: samoyeds: 9, akitas: 7, trees: 5
+Sue 425: akitas: 5, children: 4, perfumes: 9
+Sue 426: goldfish: 1, children: 9, cats: 2
+Sue 427: vizslas: 9, akitas: 7, goldfish: 9
+Sue 428: pomeranians: 7, akitas: 5, vizslas: 1
+Sue 429: vizslas: 7, goldfish: 7, cars: 9
+Sue 430: trees: 7, perfumes: 0, pomeranians: 5
+Sue 431: children: 9, perfumes: 5, vizslas: 7
+Sue 432: trees: 6, samoyeds: 7, cats: 1
+Sue 433: goldfish: 5, trees: 5, children: 6
+Sue 434: goldfish: 9, akitas: 7, cars: 3
+Sue 435: samoyeds: 10, perfumes: 2, cars: 0
+Sue 436: akitas: 5, pomeranians: 4, perfumes: 7
+Sue 437: vizslas: 5, cats: 6, perfumes: 5
+Sue 438: trees: 2, goldfish: 6, vizslas: 7
+Sue 439: samoyeds: 8, pomeranians: 10, goldfish: 1
+Sue 440: akitas: 6, children: 9, perfumes: 4
+Sue 441: cars: 2, goldfish: 9, children: 0
+Sue 442: goldfish: 7, cars: 2, vizslas: 8
+Sue 443: goldfish: 6, samoyeds: 3, perfumes: 2
+Sue 444: trees: 2, goldfish: 7, cars: 8
+Sue 445: trees: 2, pomeranians: 0, children: 0
+Sue 446: perfumes: 4, akitas: 4, goldfish: 6
+Sue 447: vizslas: 7, akitas: 9, cars: 3
+Sue 448: goldfish: 6, trees: 9, cars: 0
+Sue 449: samoyeds: 7, perfumes: 4, vizslas: 10
+Sue 450: akitas: 7, cars: 10, goldfish: 7
+Sue 451: goldfish: 4, children: 7, pomeranians: 4
+Sue 452: cats: 4, vizslas: 6, trees: 7
+Sue 453: cars: 1, trees: 10, goldfish: 9
+Sue 454: trees: 2, goldfish: 3, vizslas: 10
+Sue 455: pomeranians: 9, vizslas: 3, akitas: 2
+Sue 456: vizslas: 10, akitas: 2, goldfish: 1
+Sue 457: trees: 5, cats: 5, children: 8
+Sue 458: cars: 6, goldfish: 3, akitas: 9
+Sue 459: goldfish: 7, akitas: 2, cats: 7
+Sue 460: akitas: 1, cars: 5, children: 8
+Sue 461: cars: 8, perfumes: 0, goldfish: 6
+Sue 462: pomeranians: 6, cats: 2, perfumes: 6
+Sue 463: vizslas: 7, perfumes: 3, goldfish: 3
+Sue 464: akitas: 10, goldfish: 10, trees: 1
+Sue 465: vizslas: 0, akitas: 2, trees: 2
+Sue 466: perfumes: 6, akitas: 8, cars: 2
+Sue 467: goldfish: 1, cars: 10, perfumes: 3
+Sue 468: goldfish: 4, trees: 2, cars: 9
+Sue 469: perfumes: 6, pomeranians: 0, vizslas: 10
+Sue 470: samoyeds: 8, children: 0, akitas: 7
+Sue 471: children: 3, goldfish: 9, cats: 9
+Sue 472: samoyeds: 0, goldfish: 0, trees: 0
+Sue 473: trees: 3, goldfish: 4, vizslas: 1
+Sue 474: perfumes: 10, cars: 3, trees: 7
+Sue 475: akitas: 5, vizslas: 4, goldfish: 5
+Sue 476: children: 2, akitas: 7, vizslas: 3
+Sue 477: vizslas: 6, pomeranians: 9, trees: 6
+Sue 478: vizslas: 7, pomeranians: 6, akitas: 7
+Sue 479: trees: 2, perfumes: 2, children: 2
+Sue 480: cars: 8, cats: 5, vizslas: 0
+Sue 481: trees: 5, goldfish: 0, akitas: 3
+Sue 482: cars: 8, perfumes: 6, goldfish: 10
+Sue 483: goldfish: 0, cars: 3, perfumes: 10
+Sue 484: pomeranians: 1, samoyeds: 1, perfumes: 3
+Sue 485: trees: 0, akitas: 2, vizslas: 4
+Sue 486: cars: 3, vizslas: 8, goldfish: 1
+Sue 487: pomeranians: 9, vizslas: 2, children: 10
+Sue 488: akitas: 6, vizslas: 10, perfumes: 9
+Sue 489: goldfish: 6, vizslas: 4, cars: 2
+Sue 490: vizslas: 10, cats: 8, samoyeds: 1
+Sue 491: cats: 9, cars: 1, perfumes: 10
+Sue 492: goldfish: 6, cars: 9, pomeranians: 9
+Sue 493: children: 10, goldfish: 10, vizslas: 0
+Sue 494: pomeranians: 5, cars: 0, vizslas: 0
+Sue 495: vizslas: 7, perfumes: 6, samoyeds: 3
+Sue 496: trees: 1, cats: 4, cars: 10
+Sue 497: cats: 1, perfumes: 0, cars: 7
+Sue 498: perfumes: 7, vizslas: 6, cats: 9
+Sue 499: vizslas: 8, perfumes: 1, akitas: 3
+Sue 500: perfumes: 4, cars: 9, trees: 4

data/2015_23_data.txt

@@ -0,0 +1,49 @@
+jio a, +19
+inc a
+tpl a
+inc a
+tpl a
+inc a
+tpl a
+tpl a
+inc a
+inc a
+tpl a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+jmp +23
+tpl a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+tpl a
+inc a
+tpl a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+tpl a
+inc a
+jio a, +8
+inc b
+jie a, +4
+tpl a
+inc a
+jmp +2
+hlf a
+jmp -7

data/2020_03_data.txt

@@ -0,0 +1,323 @@
+.#..........#...#...#..#.......
+.###...#.#.##..###..#...#...#..
+#.....#................#...#.#.
+#.....#..###.............#....#
+......#.....#....#...##.....###
+....#........#.#......##....#.#
+..#.......##..#.#.#............
+#.............#..#...#.#...#...
+.#...........#.#....#..##......
+......#..##..#....#....#...##..
+....#.##.#####..#.##..........#
+..#.#......#.#.#....#.....#....
+...###.##......#..#.#...#...#..
+...#..#.#..#..#.......#........
+...#....#..#...........#.#.....
+....#.........###.#....#...#...
+....#..##.....#.##....##.#.....
+........#.#.#.....#........#...
+..#..#.....#.#...#.#...#.#.....
+....#..........#....#....#...##
+.##...#..#...##....#..#.#....#.
+.#....##..#...#................
+..#.###.........#.###.....#....
+....#..#.......###.#...........
+#...#...#.#...........#.#......
+.#..#.......##.....##...#......
+....####.#..#.#.#...........#..
+.##...#..#..#.#....##.....#..##
+...#......##....#...#.#.###....
+##.#...........#.........#...#.
+...........#...#...........##..
+.....#....#...........#........
+...#..#.........#...#....#.##..
+.....##.........#...#........##
+....#....#..#.#...#...##.#.....
+...#.#..#...#...........#..#...
+.....#.#.....#....#...#....#...
+.#.............#..##..........#
+..........#......#..##.....###.
+..#....#........#.#.....##...#.
+#..#......#.#.##......#.#.##...
+.....#..#.........#...#.#.#.#.#
+#.#...#.......#.#..##.##.....##
+.....#......##......#.......#..
+#.....#...##.#.#........#......
+#..........#.#...#.......#.....
+..#..#........#........#.......
+...#....#....#..####.#....#...#
+#.............#.....##....#..#.
+##....#.....###..##....#......#
+#.....#...#.#.............#....
+.#.#..##..##.#..#....#.#.#...#.
+.#...#..#.....#..#.#.#..#...##.
+..#.#.#.#.#.#....##...#........
+.......##.....#..........#...#.
+...#..#...#...........#....#...
+.....#..#....#..#.##...#.......
+..##..#.......#.#..#....#......
+...#...............#.#..#......
+....#........#...#....#...#.#..
+...#...#..........##....##.#...
+..###.#.##.............#..#.#.#
+##.......##.#..#.#.#.....#.#.#.
+..#####...#......##...#........
+...#.##...#................#..#
+..#......#...#....#.#..##..#...
+#.#.........#............#.....
+##.............#.#.....#......#
+....#.......#..#..##....#.#....
+...#...##....#.........#..#....
+...####.....#...........#....#.
+#.#........##....#..#..#...#...
+....#.#.###..........#........#
+#.#......#.....#.##....#.#...#.
+#....##.#..##..#.#.............
+.#.....##..#..................#
+...#.#........#...#.#........#.
+..#....#......#.....##........#
+....#...#....#...#.....#.##....
+...#........#.......##.........
+.#.##......#......#....##......
+.#...#...###.#............#..#.
+.#...........#.#.#....#...#..#.
+.#.....#....#.....#...#........
+.#..#.....#............#.#.##.#
+...###.#.............#..##.....
+...#.#.##.#..#..........#..#...
+.#.#.#....#..#...............##
+.......#.#..#...#.#.#........#.
+....#.#...#..##....#........#.#
+..........#...#.......#..#....#
+...###.....#.#....#.....##.....
+#......#..#..#........#.#...#..
+#......#....#..#.#.............
+...#....#........#...#..#......
+...#..###........#.#.........##
+#......#.#..###..#........###..
+.#.#......#.#..#.#.#.#.....#..#
+#....#.....#..##.....#.........
+....#......#...#..#..#.#.##.#..
+........#.#...#...#..#...#.#..#
+.....##........#...#....#...#..
+....#...##..#........#....##.#.
+...............#.....#......##.
+..##.....#.....#.#.............
+.....#.#...........##.#.....#..
+.#..##..#.##.#...##.#....#....#
+.##.....#.##......#....#..#..#.
+.......#.##......#....#...#.#..
+.#........#......#...##.#....#.
+.........#..........#.......###
+#.#.........#..#..#....#...#...
+.......#.........#......#.#.#..
+.......#...........#....#....#.
+.###...##.#.#..........#...#..#
+....#.....#...#..#.............
+.......##........#..#.......#..
+....##..#.#....#....#..#...#..#
+..#.####.....#.........#.#....#
+..............#.#..#.....#...#.
+.....#.............#..........#
+..##.#...#.....#....#.#....##..
+.#...#.......#..####..#..#...#.
+#..........#................##.
+......##.....#.................
+..##...#.#..........##.#...#...
+....#.#.#.#...##...#...#...####
+.............##..#.###...#.....
+#.#....#.#..#..##........#..##.
+.....#.#...............#.......
+...#..##......#..##...........#
+#..#....#...........##..#......
+.##....#.#....###.......#..#...
+.....#..#.#....##...#......#...
+.#.........#####......#...#...#
+.......#.#.....#.....#.......#.
+#....#.......###.......#..#....
+#......##.###...#.......#......
+.......#...#......#....#..#....
+.#.####.......#...#.##.........
+................##.#......#....
+......##....#.#......#......#..
+....##...##....#.........#.....
+......#.#..............##.#...#
+....#.#......#.#.............#.
+.#.#..####...#................#
+....#.#.#.#......##...##......#
+.....#.#..#......#....#......#.
+..........#.#.....#.......#...#
+..##......##.#...##.#......#..#
+...#............#..#...###.....
+.#.#..###..#.......##...#.....#
+.#....#.#.......#.....##....#..
+#.............###...##.#.#...#.
+#........#.#........#.#...#.#.#
+##..#.................#....#...
+...#.#...#..#.#..##....#...#...
+#.....#.......#..............#.
+.......###...##..#.....#.......
+#.#.........#..#.#.........#...
+.#.#............#.....##.....#.
+........#....#....#.......#....
+...#.#....#..#.##....#.#......#
+.#.....#.#..#...........#.#.#..
+#......#..#......##.#.#.#.#..#.
+.......#.#..#......#.#.#..#.#.#
+..........#...#..........#.##..
+.#.#..####.......#..........#..
+......#.#.....#..#..#..#.....#.
+.....##..#.#.#..#..#...#.....##
+............#.#....#.#....#....
+..............#..#...#...#.....
+.....#......#.......#.....#....
+..##....#..#...........#..##...
+###...#.##..#.#...####....###..
+..#.#.....#.........#....#..###
+##...........##.............#..
+....##..............#.........#
+...#...##....#.#..#...##.....#.
+..#..##...#.......#..#..#.....#
+...#...#....####........##.#...
+....#........#..#.#.........#..
+.#..........#...#..#.#.#......#
+....#.#.....#.........#....#...
+...#....#...##.......#...#.....
+....#..#.......#.##.##.##...#..
+##....##........#........##....
+.#.#..#...........#.....#...#..
+...#.##...##..#...#...##.......
+.....#..###................#.#.
+...#........##.#....##.....#.##
+...#...#..##...#...#.#...#.....
+.#......#...#..#.##.......#...#
+.....#.......###.##...#........
+#.....#..#........##.##.#.##..#
+....#..............##.##...#...
+#..........#..................#
+..##.......#..........#..#..##.
+.#....###.#..#.........###....#
+.#....#.##..............#.##.##
+.#.##.#....#.......#.#......#..
+.#............#.#.....#........
+..#......#.......#.............
+#.#...#........##...#.#......#.
+....#.........#........##..#...
+..........##.....#.#......#....
+.##.#..#....#.......#...#...##.
+.#................#...#.##.....
+....###.......#..#..#.........#
+.#.....#..##...###......#.....#
+.#.##..........#..#..#........#
+.......#.##..............#...##
+#...#.#.#.......#..#......#.##.
+.#....#.#......#...#..........#
+.....#........##....#.##.....#.
+.#....................#..#.#.#.
+.....#.........#....#.......#.#
+.....#.#..##..#.....#..#.......
+...#..#..#...#.....#....#....#.
+#.....#.#.#..........#..#.#.#..
+.....##..##.....#.#..#.........
+#.#..##....##......##...#.##..#
+..##..#.....#..#..........##...
+......#.#...#..#.......##.....#
+..#.#.......#.#......#.........
+.....#........##..#.....####.#.
+.#.....#........#.......#..##..
+......#...#....#.##...#.......#
+..##..................#..#.....
+.....###.#..##...#.............
+...##...##...#......#....#....#
+#........#.#..........##..#....
+#........#....#..........#...#.
+...##.#.##..#...##......#......
+#........##....#.#..##.....#..#
+...####......#..#......#.#.....
+.#......#...#...#.#.....##....#
+.....###..##..#...#..........##
+##.##....#...#.................
+...##.#.......#.###......#..#..
+.....#.#.#.......#.......#..#.#
+#...#...#.##..#....###.......#.
+.#.#..##.....#....#...##.......
+.....#..........#....#...#.##..
+..........#....#...#...........
+.#....#..#...#...#.......#....#
+#..#..............#.....####.##
+.......#....###....#....#.#.#..
+###.#........##.#.......#......
+#..#...#..#......#.............
+#...###..#...#..#..##.#.###.#..
+..#..#...##......##............
+.#..#.......#..###..##...#.....
+....#..#..##.#.#.....##...#.#.#
+....#....#.....#..#....#.......
+..##..#....#.#...##..#.........
+.....#....#...........#.#......
+...#........#.#..#..#......#..#
+.#...##....#....#.#.##......#.#
+..#...........#..###.##.....#..
+.#.######.#..##.......#..#.....
+.....#..#......##.#.#...#......
+....#....#..#.....#.......#.#.#
+.....#........##.....#.....#.##
+........#....#...#...#.#.#...#.
+...#.#.....#...........#.....#.
+#.#.#...###......#.....#.....#.
+.#..........#.....#.......##...
+#................#.#.....#.####
+.#......#......#.#..##.#.##....
+..........#....#...........###.
+.##....#..####..#####..........
+##.......##............#.....#.
+...#.....#...#....#.......#....
+.#....##......#.#...#....#.....
+....#............##..........#.
+.#....#....#.....#.#...........
+.............##.#.##...#.#.#...
+..#............#.#..##.#....##.
+#.....#...##..........#.#.#...#
+......#............#..........#
+..##..#.....#........#.##..#..#
+#..#.#..##.#.....##.#..........
+#..#...#.#..#......##.......##.
+.##......#...........##.....#..
+...#.....#.....#..#....#.......
+.....#...............#........#
+.......#.....##..#..##..#.#.#..
+#.#.....#..#..........##...#...
+#..#......#.................#.#
+.##...#....#...#...#.......#...
+.#........##........#..........
+........#..........#.........#.
+.....#.##..#.......#........#..
+..##..#..#...##..#.#....#......
+......#........#.##.....#.#....
+.#...#.#.........#..#.#.#.#..#.
+.#..#.#...#............#.#..#..
+....#.................#...#..##
+.........##.....#.#.#......####
+...............#....##.#.#.....
+....##..#....#......#....#.....
+....##.#...#....#.#..#...#..#..
+..##......#.#..#........#.#.#..
+.........#.#................##.
+##.....#.....##..##.#........#.
+###....#..#..#..#..#.##..##.#..
+.....##..#...........##..#.#...
+....#..#..#..#....#...#.#....#.
+#....#............#..#....###..
+....#..#.............#....##.#.
+...#.................#...#.....
+.##...#....#..#..#........#....
+...#.#..#...#.#......#....#....
+...#.......##..........#...#.#.
+...##..#.......#........#...#..
+.....#.#.#....#..##......##...#
+....##......#........##....##..
+..#..........#.#.##.....#......
+..................#..#..#..###.
+.#..............#.#..#.#..#.###
+..#....#....#......#..##..#...#
+#.........#..#..#...........#..

data/2024_04_data.txt

@@ -0,0 +1,140 @@
+ASAMXXXXSSMMSMAXSAXXXMAMXAMXMMAMXMMMMSSMMMMMMMMMSMXSASXSMXMMMXAMSSSMSSXMXMASMSMMMSMASXMMMAMXMXMMXSXMASMSMXMASMXSMXMAMXMMSMSASAMXSXMAMSAMXSSS
+SAMXSXXMAAAAXMXSAMXSMXMSSXXAMMAMAMXMAMASMAMAXMAMXAXSAXAXAASAMSAMAAAAAAASXMASMSAXAAXAMAMXMMXSSMMSAMXSXAAAAASAMXAMASXMASXAAAXASMSMSAAAXXAXXMAM
+MAMAAAMAXSMMMMXSAXMAMAMMAMSMMSXSASMMMSAMXAXMSSXSMMMMMMSMSMSAMSAMMXMMMMASAMAMXSAMSSMMSMSMSMAMXAXMASAMXMSMXMSMXMXMAMAMASMMMSMMMAAAMXMAMMSMAMAM
+SAMXSSXSMMMSAMASXMMASAMSAMAMXMAMMMXAMMASXSSMAMAAXXAAAMAAXXMMMSXMXSXAAXAMXMAMAMXMXAMXAAAAAMAMMSMMSAMXAMAMSMXMAMAMAXAMXMAAAXAAMMMMMXMAMSAMXSMS
+MXMAMAAAXAAMAMMMMXSAMMXSMSXSAAMSMSMMMXASAMXMAXSMMXSMSSMSSMXMASMXXAMMMMSSXSASMMMASXMMMSMSMSXSAMAXXAXMXXASAMAXAXAMMMSXXXMMSSSMXSASASMSMAAXMAXA
+XSAMXMSMMMSXXMASMMMSSMAMXXXSXSXAXAAAMMXMMMXMXXAAXMMAMXXAAMMMXSASXMAXXAXXASAXAAXMXMXSAMXAAXXMASMXSSMSSSXSAMXSSSMMSAMASMMAAAAAASMAAXAAMMMASXMS
+MSASXXXASAMMXMAAXAAMXMSSSMAXAMMMSXSMSAMMSSMMMASAAAMAMMMSSMASMMAMXXMSMSSMASMSSMSMMASMASXMSMSAMXMXAAAAASMSMMMAMAMAMAXAAAMMMSMMXSAMXMXMSXMASAAA
+MSAMMXSXMAXAMMXSSMSMXMAAAMSMXMSXMAXAXXXAAMXAXMAMMSSMMMXAAXASAMAMSSXMMAMAASAAXXAAASXMSMXXAASXMASMSMMMXMXSASAAMAMAMAMMSAMXAAAXASAXMMAASMMASMMM
+MMXMSMMMMSMSMSXAAXAXAAMXMMAAASASMAMAMXMMSSSSSXXMAAXAAXMASMMXAMMAAXMAMMMSAMMMSSMMMXAXXMXMMXMAMXSAXXAXMAMSAMMMSMSSSSXXAMSMMSMMMSXMASMSMAMAMAXX
+XMAMASAAXXAXAXMMMSXSMXSAMSMXMXAXMASAMXAXXXAMXMXMMSSSMSXAMMMSSMMMMSASMMMMMMMXXXMASAMXMASXMASAMMMMMSMSAMXMAMXMAMMMAAAXASMMAAAAXMAMXAMXMMMSSMMS
+XXAMASXSSMMMAMXSAMXXAAXMXAMASMXMAXSASXSMMMSMAXAMXMAAASMMXXMAMXAAXMXMAMXAAAAXAMAMMAMASAMXSMSAXSAMASXAXXXSSMAMAMAMSMMMMAAMSSSMSMXSMAAAXXSAAAAM
+SSXXAMAMXMAMSAMAXXXMMMSXSASAXAAXXXSAMAAXSMXMMXMMMMMMMMAMAMSASXSSMSMSSMSSSSSMXMASXMMASXMAMXSAMSASAMXMSMMMMXMMMSAMXAXMXMSMAAXASAAMXMMASXMSXMMS
+MAMMSMMMAAXMXAMXMMSXSAAAXAMASMMMSAMAMXMMMASXMASASMMSXSAMMXSASAAAAAAAXAXAAXXAAXAXAMMMSAMMSAMAMSAMMXMXMASASASAASMMSMMMSXXXMXMMMMXSAMXMAMMXMSXM
+MMMAXASXSMSXXXMAAXXAMMSSMAMMMXAAMAMXSSMAAXMASASAMAXAAMXSXAMMMMMMSMSMMAMMMMXSAMSSSMSASMMAMXSAMMAMSASASXSAXAMMMMAMXAAMSAMMXMASAMMSMSASAXMAXMAM
+SAMXSAMAMASMSSSSSXMAMAAXXXMXAMMXSMXAAAMSSSSXMAMMMSSMXMASMXMASAMXMMAXMXMAMXXMMSMAMAMASXSMSXSMSSMASASXSAMAMSXMASMMSMMXMAMXAAASASAMXSAXXAMXMSAM
+MXMMMMMSMAMAXXAAAASXMASMSSMMXMSAMXMMSSMMAXXXMXMAAXAXAMXSAXSASASAMSMSAMXSMSXMSAMAMAMMMAMXSAXXAAMAMMMXMMMXAAAXXSMASXMASAMXAXAXAMMSAMXMSSXMMSAX
+SSMAAXAAMMMSSMMMMMMAMAMASAAXAMMXXMXMAMAMXSSMMXSMSXXMMSMXAXMAXASXMAMMAAAAAXAXMASAXAAXMAMSMMMMSSMAXAMXXXAXASMMAMMAMASASASMSMSMAXAMXSSMAMASAMXS
+XASMSMSSSXAXAAAAASXMMAMXSAMMSSMAXSAMASAMXXAXMASMMXMMASAMMMMMMMMXMAXXXMSMSMMMSMMXASXSMAXAAXXAAAXMSSMMAMSMMAAMAMMMSAMASAMAAAXSXMMSMSMMASMMMAXA
+SMMMMAMXMMMSSMMSXSAXMAMASAMXXAMSXSAMAXASXXSMSXSASAMMAXAASAAXXSSSSSMSAAAXAAAAAXMAMXAAMXSSSMMMMSXMAMXSAMAAMSXSASAMXMMMXMASMSMMXMXAXMASASXMMMMM
+MXSAMAMMSAAAMAXMASXMMSMMXAMSXMMXASAMSSMMMMAAXMMMSASMSSXXSMMSXAAAAAAAMMMSSSMSSSXSMMSMMXAAAAXASMMMXSMSASXSMXMSAXMSAXASMXMAXXAMSASXSMXAMXMAAAAX
+MASASASASMSMSSMMMMASAMXXMSMSAMXMAMXMXAMAXSMMMXSXSAMAMAMXXXAXMMMMSMMMXAXAMXMXAXAMMAXAAXMSMMMXAAMAAMASXMAMXMMMXMXSXSMSAASMMXAMSASXMMSAMXAMXSSS
+MXSAMAAMXAAXMAAMASAMASMXMXASXMSMAMSASXMAMSXMSAMXMAMXMAMSAXMMSXMAXAAXSMMAMXMMAMMMASMMSXXXAAXSSSMMXSAMXXAXAMXAXSXSXMASXMMAMXSMMXMAMAMMMMSSMAXA
+MMSXMXMAMSMXXMXSAMASAMASMMAMASAXAXMAMAMMSMAXMASASXMXMMMMAXMAAAMSSSMMAXSAMAXMASAAXXAAAXAMSMMXXAAAAMAMASMSSXMAMXAXMMMMMMSMMAMAMMSAMAXAAAAAMMMM
+XAXAMXXXAMXSASAMASAMAMAAASASXMMSXSMAMMAMAMXMMASXSMMMSMAXSMMSSSMXAMMXMASASMXSASMMSSMMMMSAMXXMMSMMMMAMASMAXAMSSMMMSAMXAAAAXXSAMXSASAMSXSMMSXMX
+MXSSMASMAAAMXMASAMMMXMMSAMASAMXSAAXAMXASAXAAMXSMSAAAXMXMXAXAAAMSAMXAXXSAMAAMASAAXXMMXXMASMMMMAAXASAMXXMXMAAAXAMAMMMSMSSSMAXAMXSAMMXXAAAXXAMX
+AXAMXAXSMMSSSMXSASAASXMAXMXMXMAMXMMMXSMSASMSMASASXMSSMMASXMMSMMXMASXSXMXMMMMMMMMSASXSAMXXAAAXXXXASAMMSMMASMASXMSMSASAAXAMXSSSMMMMXAMSMMMSSMS
+SASMMSXXXXXAAXAXAMXAMASAMSAMXMXSSMXSAMXMAMAAMMMXXAMXAAAMMSMAAXSAMXMXMASMSXXXXAXMMMMASXMAMSMSSMSAAMAMXAAAMAAASAAXAMASMXSXAXAAAXMASMMXXASMAAAX
+MMXXAMXSAXMXMMMSXMXSMAMASMMSAMMMAAAMMSSMAMSXMXXMSMMSMAMXAAMMXSAMXAMAXSMMAXASMMXSXSMXMXMMMMAMXAMMSSSSSMSMSMMASMMMAMAMMXMXMMMSMMXAXAXASAMMSMMM
+SXXMMMAMMSMAXXMAAMAMMAMXMAAMMMAXMMMSAAMSAXAMSMSMAXXXXXMMSMSMXMAXMXXAXXAXMSMSAAASAMMAAXMAAMAMMSMAAAXAAAMAMXSMMMAAXMAXAAMAMMMMAAXSSMMMSAXXXAMX
+SAMSAMXSAAXMAXXXXMASXMXXMMMSSSMSAMXMMSMXXXXAAAAAXAXMAMMMMAAXSXSMMSMSXSAMXAXSMMMSAASXSSSMSSXMAMMMMSMMMMMAAAMAAMXMMXXMSMXASAAMMMSXAMAXSXMAXAMM
+MAMAASMMXMSMMSSXASASMSMSMMXAMAMMAMSMAMXXSSXSMSMSXMXAMXSAMXMXSAAXXAAXAXMXMMXXXXXSXMMXAMMAMXMMMMAXXAXAAASXMAXSMMSMSASXMXSASMXMAMAMXMSXMASXSXMA
+SXMMMSXAMXSXAAMMMSAMAAAXXMMMSAXMAMAMAXXMMAAMAXAMXXSAMASAMAXAMMMSXMSMMMSAMXSSMSMSXXMMSMMXSAMAMXXMSMSSMMXMASAXXXAAMASAAASXMASXMMAMMMAMSMMAAMMX
+MMMXAMMMSAMMMXMAXMAMSMSMSXSMSASMSMMSSXSASMMMSMAXAMSAMMSAMSMMMSAMXAXAAAXASAXAAAAXSASAMAMASMSASAMMAXAMMMAXAXMMMSMSMAMMMMXAMAMMMMASASAMAXXSMAXS
+MASAAXSAMXMAASXSSSMMXAAAXMAAMXMAAAXXAAAMMASXXMSMSASAMXMMMXAAAMASMMSSMSSMMMXMSMMAMXMASAMAXXMAXXASXMASMSSMMSAAXAAAMAMAXSXSMXXAXXMSASASXSMMXSMA
+SSSSSMMMXSASMMMMAAMSMSMSSSMSMASXSMMMMMMXSAMMSAMAMXSMMXAASXMMMSAXAAAAMMAMXSXXXMASXXMAMXMASXMSMXXAXMASAAXAMSMMSMSXSMSSXSAMAXSXSSMSASXMXMAAAMAM
+SXMAMAAMASMMMAMMSMMAAXAAAAAXMMMAAMXAAMSMMAMXMAMAMAMMMSSMSAAAXMMSMMXXMXXSASXSASAMAXMMMSMMSXAMASAMXMMXMMSMMMAMXMMMXMAMAMAMSMAMXAAMMMXMAXMMSXSX
+MAMASMMMAMXASXSAAMSMXMMMSMMMAXMSMMXXXMAAXMMSMMMSMAMAAMAMSXMMXMXAAXSSMAMMMSASAMASAMXXASAMSMXMAXMMXSSMSAAAXSAMAAAXAMXSAXMMXMMAMMMMASAMAMMAMAMX
+SAMASAMMMMMMXAMMXMAXSSMXMAMSMMMXAMMSSSSSMAAXAMAASXMMMSAMSAMXAXSMSMAAMXXAMMXMAMXMMSXMXSAXMASMSSMAXAAMMMSSXXAXSSXSMSAXMSMMASMSMAMSAMMSASMAMMXA
+SASMMMXAXSASXMASXMAXAASXMAMXMASXXMASXAAMXMSSMMMXSMMSASMMSAMSSMMAAMMMMMSSSMMSSMXAASAMASMMMMSXAAXASMXMAMXXMXSMMMAMXMXSAAASXXAASAMMSSXAASMMMXMX
+XAMXASMMXSASAXSAMXMMSAMMSXSASMSXMMSXMXMMSAXAAASXMAXAAXMASAMXMASMMSMAMMAMAXXAMXMMMMAMASAMXAXMSSMXMXSMAXSAMAXAAMXMAAXMXSMMMMSMSMXAMXMMMMAMASAA
+SMSSXMASXMAMAMMAMXXXMAMAAXSAMSMASMMXSAAASXSXMMAMXXXMXMMXMAMAMXMAAXMAMMASAMMSSXMASXMMASAMMMSAMMMXSAMMMXSMMAXAMXMSMSXSAMXSAAAAXAMSXSAMASAMMSSM
+AMAXMMMMMMAMAMXAMMMXSAMSSMMSXAXAMAAASMMMMASMSAMSXSAXXMASXSMMMAXAMXSSSSXMASAAMASASAXXAXAMAAMXSAASMSMASXMASXSXXAAXXAXMASAMXSMXMAMAAAXSASASXXAX
+MMSSMASAXSXMMXSAMAAXSAXAXXAAXMMSSMMMSXXXMAMXSXXAAMMMXMXMAMAXSAXSAAMAAXMASMMSSMMASMMMSSSSMMXXMMXXAAXXSASAMAAASMSMSMXSXMASAMMAAMMMMMXMASXMMSMM
+XAMAMMMAMSMMSASASASMSXMASMXSSXAAAASXSAMXMXSASMMMSMXXXXAMXMXMAAXMAMMMMMXSXSMAAMMMMAAAXAMMMSMMSMSMSMSMSMMAXMMMXAAAXMASMSAMAASMSMXMASXMXMASAAAA
+MSSXMMMSMMAXMASAMAMAMXMSMXMMAMMSSMMMXSASXAMMSMAAAXAMSXMXXMASMAAXSMMSSSMXAXMSSMAASMMSMSMXAAAAAAAAAAAXXXSSMSAXMSMMMMXSAMXSMMMAAMXSASAMASMMSSSS
+SAMMAXAXAXSXMMMXMAMMSAMMSXMMMSMMAMASXXSSMMSXMASXMSXMAAXAMXMXXMSAMXXAAAAMSMXMMXSMSXAAAAAMSXSSMMMSMSMSXMAMXSXXXAXXAMMMMMAXXMXSMMXMXSXSASAAAMMX
+MASAMMMMMMMAMAAAMAXASASAAXXAXAAXMSXXAMAMAXXMXMAAASAMSSMASXMMMAXAMXMMSMMMXXAAMAMXMMMMMMSMMAXMXMMMMMXMAXAXXMMMSMXSASMAMMMSSMAXAXXMASAMXXMMMXXM
+SAMXXAMASXSSMMSMXSAMSAMXXMSMSSSMXSAMSMASXMSMAMMSMSAMAMAMMASAMXXAMXMAMAMAXSSSMASAMAAMASAMMSMAAXAAAMMSSMMXAAAAAAMSAXMAMMXAAMSSMMMMASAMMXSAMMAA
+MXSXSMSMSAAXSXMXAMMXMAMAAMXMAMAMAMXMXAASAAAMXSXMAMXMXSAMSXSXSSSSMSMXSAMAXAXMXMXASXXSMSAXSAMXMSSXMMMAXASMSXMXSSXMXMSSSMMSSMAMMAAMMSAMAMMAASXM
+XSMMSXAXMMMMSXSMSSXXSMMSMSAMXSAMXSSMSSMSMSMASXMMAMAXXXAMAMXMMMAXAXAASAMXMAXMAXSXMAXXXMMMMSMAXXMASAMMSXSAMASMMXMSMAAAAXAMMAMXMMMMXMAMSXMSMSAM
+XAAAXASMSMAAXAXAXMXMMAMAXMAMASASAXAAAAXXAAAMMAMSXSMSSSMMMXAAAMSMSMMMMAMXMAXSAXXAMSSMAXSAAAXMMAMASASXMAMAMAMASAAASXMSMMMXMXAMXXSMSSSMMAXAAXXX
+MSSMSAMAXSMXSMMSMMASXSMSSSSMXSAMASMMMSMMSMSXSMMMMSXAMAMSMSSSMSXAAXAMSSMMSAMXMMSAMAAMAMAMXSMMXAMXMAMXMAMAMAMMSMMXMXMAMXMASMMMSXAAAAAASMMMMMSM
+XXMAXAMXMXSAAXAXASAXMAAAAXAAXMXMAMAAXAAXAXMASXAXAMMASAMAAAXAXXMSMSMXAAAMXMAMAMMMMSMMMSXXAMASMSMSSMMXSMSMSAMXXAMSSMMAMXSASASAMSMMMSMMMAAAXMMS
+SMSSMSMMSAMMSMMSXMASMMMMSMMSXSAMASMMSSSMMSMAMMAMXSAXMASXMMSMMMAAAXMASMMMAXAMSSSXAMASASXMASASAAAAMASAMXAMSXSSMAMAAASMMAMMMAMAMXXXMAXMMSSMXMAM
+XAXAMXAAMASAXAAMAMSMXAXAXAXAAMXSASAAXXAAXXMASMSXXMMSSMMXAXXMAAMMSXMAMAAMMMXSAAMMSSXMAXMAXAAMXMMMSXMASMSMSXAMSMMMSMMAMMMSMASXMAMMXAXSAAAXSMSS
+MSXSMSMMMAMAXMAXXMASMXMMSMMMSMXSAMMXMSSMMMSMXAXXSAAMAMAXMMMMSSSXXMMASXMMXAXMMXMAXMMMSMASXMXMXXAMSMSXMAMASAMXAMAXMAMSMSAXSAMAMAMSMMMMMSSSMAMS
+AAAXMXXSSMMMMSXSASAMMXMAMMAAAMXMAMXAXXXMAAAMMXMMMMMSAMSXSAAAAAXMASMXSAMXXMXSXMMXXAAAAAMMAXXMSSSSSXSAXMMMMAXSSSMXSAXXAMMXMXSAMAXSAMXXMAXMAAMM
+SMSMSMMMAXXMXAAMAMAXSAMASXMMAMMMSMSXSASMMSSSXXMAAAAMASMASXXMMSMMXSXXMAMXAXMAMXSASXMSXSXAMSMMAAXXMAMAMMAMSSMMMAMMMAMMAMXAAAXAMXXSXMSAMSSSSMSX
+XAAAXXAXMMXMMMSMSMMMSASASXMXSMSAXXSXMXSAAAXXAXSASMXSXMMAMMXMXAAMXMASMAMXMSAMSAMXXXAMAXXMXAASMSMSMXMAMXAMMXAAMAMXAMASAMMMSSXSMMMMSXXAAAAXXAXX
+MSMMMMMXAXXMAMAMXAXXSAMXSASAXXMAMAMXMASMMMMMMMXAMAASMXMXMAASXSSMAXMASAMXSAMXMXSMAMSMAMAMXMMMAAAXAXSXMMSSMXSMSAXXXMMSASXXAXXAXAAXAMSXMMSMMAMX
+XXSXAASMMMMSMSAXSAMXMSMMSAMASMMMMSMXMASAMAAAAMMMMMMMAAMMMSXSAMMMMSAXXMSMMAMSMMAAAAMMSXXMASMMSMSMSMMASAMAXAMMMMAMXMXSAMXMASAMSSSSMMMAMMMAMSMS
+SAMMMMSAMXMAXXXMSAMASASAMXMXSAXMAXAAMXSASMXSAXSAMXSMSXMAXMAMAMASXAMMMMAMMAMXASXXXXMAMAAMMXAAXSAMAASAMASAMMMSAMMAMXAMAMMMMMMXMAAMXXSXMAMAXAAA
+MAMXMMXXMAMXSMSXSAMXSASMMASMSMMXASMXSASMMAAMAAMSMASMASXMMMAMXMASMXMAXSAXSAXSXMMMSSMAMSMMASMMMAMSXXMXSMMXXSAMXSMSXMASXMASAAXAMMMMMAMMSXSXSMSM
+SXMXXSSMSXMSAAXAXAMAMXMAMXSAMXSMXMAMMMSSMMMMMMSAMXSMAXXSMSSMSMXSMMSAMSAMSXXMMASAAAMMXXXXMAASAMXMXSAMXXAXMASMASAMXMAAMXXXMSSMSXAAAXXAMMXAXAXX
+MAMXMAAASAMMMMMMSMMAXMASAXMAMAXMAMXMSXMAXXSAMXSMSASMMSAAXAAMMMAMAAMXMMAMMMSASAMMSSMMSAMXXXXAMXXXAXASMMMMMAXMASAMXMSMSSMMAXMAMMSXSSMMSSMMMMMM
+SAMAASMMMMMSMSAXAXSXSXAXASXMMSSSMSXMXAXAMMMMSMSXMASAAMXMMXXMXSAMMMSSSSMMSASXMXSXMMXMMASMSSMMSMSMXSAMAAAAASXMASXSMMXXMAAMSMMAMMMMMMASAXAXASAA
+MAXMXMAMAAAAASAXXMSAAMAXAMAMAXMAXXMMSSMMXAAXAAMMMMMMMXSSXXASAXASXMAMAAAAMMSXMMMMSAMXMAMMMAASAAAAXMASMMMSMMAMXSASXAXAAMXMAAXAXAAAAASMXSMMASAS
+SSMSASASXSSMMMAMSMMXMASMAMXMASXMMXAMAMAMXXMMMXMAAAXAASMAMSAMASXMXMMMMMMMSSMXXAMXMMMAMASAMXMSASMSMSAMAMAMAMXMMMAMMSMSMXXSMSMSMXMXXMXMXSAMXSAX
+SMAXAXASAXXXAMAMAAMXMAMXAMXXXMMSSSSSSSMMSAAASASMSSSMSAMAMMMMXMMAASXMASMMXAXAMSXMMSSSSMSMSMXSXMAMXMMSMMASMMSXXMAXXMAXXMMSAMAXASMSSMMSAMXSMMMS
+MMSMMMSMMMMSMSXSXXMAXAMMSSMMSMAXAAAAMMXASMSMSASAAAXXAMMMSAMXXMMSMMAXAXAXMXMSMXAAXAMMAMMAMMMMASXMAXMAMMMSAAXAXMMSMMAMASAMXMAMAMMAAXXMASAMXAAA
+XAXAXXMAXMAAXSMMXXSXSXSAAAXAAMXSMMMMSAMXSAAXMAMXMAMMMXMAXMSMSXAXMSSMSSSMSMAMASXMMMSSSMMAMAASAMAMXXMMSSMMMXMSMXMAXMASXMSSXMMMXMMSMMXSMMMSSMMS
+MASMMSSSMMSSXMASXXSAMAMMSMMSMSMAMXSXMASXMXMMMSMSSXMAMAMSSMAAAMASAAXAAXXAAXSMAMASAXAAAASXSXMMASXMMSSMAMAASAMAAASMMSAMXAXMXMASXMAAAMXMMSXAMXAA
+SAMXAMAMXXXAASMMMMMAMXMXXMXXXMAMXAMAMASAMMMMAMXAXMSASXSAAMMSSMMMMMMMMSMXMMMMXSAMMMMSMMMAMMMSMMAAAASMAXSMXASMSMXAMMSMMMMSASASAMSSXMAXXSMSXMAS
+MMMSSMMMXMASAMXAAAXXMXMMXMAXAXSXMMSMMMSAMAAMMMMMSXSASMMMMMMAXAXXSXAMXMAASXMAXMMSMMXAXAMXSAXXMSAMMSSMXMAMSMMMMMSSMAXXAXAMMSMMAMAAMSXSMXAXSASM
+SXMAAAXMASAMASMSSSSSXAXXAMSSMSMAXAAXAXMMMMXXAAAXMMMMMAAAMSMMSMMMMMSAMXSXSASXSXAAASMMSXSASXSXAXAXSAMASMMMAAMSAAMAMASMSMXMAMASAMXSAAASXMXMASXX
+XASMSMMMAMAXXMXMAMAXSMMMMSMAXAXAMSMSSSSSXMASXMMAXAAMXMMMMAAMXAAXAMAXMAMXMAMMMMSSXMAMAXMAMAMMSMMMMAMAMASMSXMMMXSAMAXAAAASXSMMMAMXMMSMAMMAMXXM
+XXMAAAXXSMSSSMXMAMXMSXAAXAXMMMXMAXAAAXASXXXMAASASXMSAMXXMSSSXSSXXSAAMSSMMSMAAAXMASMMMSMMMAXAAAAXMAMXSAMAXXSASASXXXMSMMMAAXAAXXMMMSAXXMMSXMXA
+SSMSMMSMMAAAAMAMAMSAXMSMSSMXMXMXMMMMXMMMMMAMSMMASAASMSXMAMAMXAAMMMMSXAAXXAAMMXSSXMAAXSAASAMXSSMSSSMMMMXXMASASAMAXSMXXAMMXMMMXMAAMXASXSAMAMXS
+SAAMXXAAMMMSMSSMSAXSMAAMAMMAAAMASXSSSSMAAAXXXXMAMMMMXXAMSMAMMMMMAAXXMSSMXMSMMSMMASMMMMMMSAMXXAAXAAMSASXXXAMMMAMSMMASMMXSAMAAXXSMSMAMAMMSAMAM
+MMMMXSMXMXAMMXAAXAMXSXXMAMXXSAXAXXAMAAXSSSMMMXAXXMSXMXXMAMAMAAAXSSMMAMMMXXAMXAAXAMAMXSAAXXMMMMMMMMMSASASMASXMSAXAMAMAAASASXSSXXAAMAMMMXXMMAS
+AAXXAXMAMMMXMMSMMXMMASXMSMSMXXMSSMMMXSMMXAAAAAXMAXMAMMSSSSXMSSSXXMAMSMMXXMAMSMMMXSXMAMMSSMMSAAXSXMAMSMAXSSMMAMASXMASXMMSAMXAAMMSMSASXMMSASXS
+MAMMMXXAMAXSXAAAMXSMAMXAMAAASAMAAXXAAMAMMSMMXAMXXASAMMXAAXAMXAMXMSAMMSMASMMMSAXSXMAMXSAMAAAMSSSMAXXXAMSMMMASXMXMASMMMMMMAMMMMAAXXSASAAAAAXAS
+MSSMAASXSXSAMXSAMAMMSXMMMSMMMAMSSMMMXSAMAXASXSSSSMSAMXMMMMMMMAMXASASXAMAMAMAMAXSMSASMMMSMMMMAMAXMMSMMMMAMMAMAXXSXMAAXSASAMXXAXSMXSXSXMXMXMAM
+SMAMMAMXAXMMXMMAMXSAXXASAMMSSXMAAAXAMSMMXSAMAAXAMXSAMMXAAAXAMASMXMMMXMMSSSMSMXMMASASAAMXMAXMMSSMXAAAAAMAMMSSMMMAMSSXMSAXMSSMMSXXASAMXXMXSASM
+AXXMAMSMSMSXSSXXXXMAMXSMASAMSXMAXSMMMMXAXMMMMMMSMASAMXXSXSXMXAXMXSSSMXMXAXAXXXXMMMMMXSSMSSSSMAAMMSSSMMMAXAXAMAAAMMMSAMXMXAXAMAMAMMAMAASAMSAM
+MMSSSMXMAAAAXSMMASMMMSXXAMXSMMSSMXMMXSMXSXXAAAAXMXSSXMAXSMASMSXSMXAAMMSMMMSMXMXMSXSAAXAXAMXAMSSMXAAMASXXMSSMSSSMMAMMXMASMAXSMASMXSMMXSMAXAMM
+XMAAXMAMMXMMMMSAMXAMSASAMMMAAAAAAMAXAAAAMASMSMAMSXXMXMAXASAMAMAAMMSMMAMAMSXMMSMMAMMMSSMMMSMMXAMXAMXMASAAXXAAMAAMMSSMMSASMSMXSXAMMXMASAXSMMXA
+ASMMMSASXMXSAMASMMAMMAMMXMASMMSSMSXMAXXAXXSXMXSAMXMXXMMSMMMMAMMMMAXAMASXMAXSAAAMMSAAMAXAAAMXSSXSAMXMASXSMSMMMMMMXMAMMMAMAMAXSMMAAMAXMMAXAMXM
+XXXAAXASASXSASMMXSASMAMXAMXMAXXMAMAMXMXSMMSAAAMASXSSMXAAXASXSSSXMMSMSASAMMSMSMSMASMXSAMMSXSASAXXXAMMASMXAAXAXAMXMSAMMASMAMSMXAXAMSMMASMSXMXS
+SXMMMXAXAMXSXMXMAXASXMXSMXAMMMMASXMSMMAMAMSMMXSAMMAAAASMSMSAAAAAAAAXMASAMXAXXXXMXSAXMASAMXMXSMSMSMMMAMXMSMSSSSSMXMASAAMMXXMASXMMMAXXMMASMXXA
+MSMAMMSMMMXXAMMSSMMMMMMXMSXSAASAXXAAAMASAMXXXAMXSMSMMMMAMAMMMMMSMSSXSAMXSSMSAMXAXMAMMSMAMASASXAAAXXMSMMXXXXAAAXMAASXMASXSXXMMAMXAAASAXAMSMMM
+AAMSMAXAMXSSMMAAAAXMAXMAMAMSXMMAXMMMSMASXMXMSMXXMAMAXXMAMXMXSXXAXXAMXMXAAAMSASMSMMMSMMMASMMASAMXMXSXMASMSMMMMMMXMMXAMXAASAMSSMAMMXMAMMMSXXSX
+SMSAMXSXMXMAAMMSSMMSSMSAMAMMMMMSMSAXXMASMXXAAMSSMMMMSASAMASXMMSMSSSMAMMSSMMSAMAXXXAAASMMMAMXMXMASASASXMAXSAAAXXSXMSAMXMXMAMAAXSXSSMMXAXAAAAS
+XXSXSAMXMASXMMAXAXMAMXSXSASAASXMAAAXSSMMMSASXXAXXMAMAMSASASASASXAAXSXSAMAMXMAMSMMMSSMMAMSMSMSXSXMAXAMXMSMMSSSSXSAAXSSXSMSXMSSMMMXAXXSASAMXMS
+MASAMXSASXSXXXMSAMXSAMXAAXXXMSAMXMSMMXAAAXMMSMAXMXASMXMAMASAMSXMMSMMSMASASXSAMXSAAMMAMXMAAAAXAAXMAMMMMMXAXAXAMASMMMAXAMXSAMXXXAAXSMXSAMXSMMX
+MAMAXXMMMXSXXSAMXMMMXSMXMSMMMMMMMAMAMSMMSSMAXXMAAXMSXSMMMAMXMAMXAMXMAMXMASXMASASXSMSSMASMSMSMSMMMAMAAMSSMMMXMMMMXAAMMSMAMAMAMMMSSMMAMAMAXASA
+MXMMMSMSMAMMMAAAXSXMAMMAXXASMMSAMASMMAASXAMAMAMMSAMMAMAAMSSSMMSMASXSMSSMAMAMAMASAMMAMXMMAMMAXAAXSAXXMMXAAXAASASMSMSXAAMXSMMXSAMXAAMXSSMMXMMS
+SXSAAXAAMMMAXMMMMSAMASXSXSAMAASASASASMSSSMMSSMXAXMASASMMMAAXXAAMXMASXAAMASAMAMMMMMMSSXXXAMXSSMSMMAXSASXSMMSXMASAMXXMMXXMAMMAMMSSSMSMMMAAXSAM
+AASMSMSMSASXSMSXASAMXXAAAMMMMMMXMASXMMMMAXAXMAMXSXASASXAMMSMMMSMXMXMSSMMAMXXXSXAMXAAXXMMSXXXAMXAMAMMAMAAXXXSMXMASMMASXMSMSMASMMAMXXAXSMMSMAS
+MMMAAXAAXMMAMAAAXSXMXMMMMMMSXMXAMXMASAAMMMSMMAXXMMAMAMMSSXAASAXMSXSAXXXMMXSAMXMXXMXSMMMAXAMSMMSMMXXMMMSMMMAAXXMASAMAMAAAAAMMMAMXMMSAMXMSAMXM
+SAMXMMSMMXMAMXXXMMAMXXAAAXXXAMSMSMMASXSMMAAASASXXAXMXMAXXXSXMASAMAMAMMMXAAAXMSXMSSMXAAMAXAMXMMMXMMSSXAAXASMMSSMASXMXSMSMXMSXSAMMMAMAMAXXAXMX
+SASXXAAXAXSASMASMXAXXSSSMXAMXMAMSAMASAMAMXMAMAAAXASMSMXSMAXMMAMAMXMAAAMMMXSMMAAAXAASMMMMSSMXSASAXAAAXSMMMAAXAXMMXAMAXXXMXMMMSASASMSMMSSMMSSS
+SSMASMMSMXMAMAMAASXSXXMAXAAMXMXMMAMXSASMMSAMSXMAXAXAAMAAAAXXMXSAMXMSSMSASMXAXXSMXMMMMXMAAAMMSAMMMMSSMMXXMSAMXSXMXSMMSMSXSAAAXASMSXXAXAAAAAXX
+SAXAMAXSASMSMSXMMXAXASMAMSXMASMXSAMAMMMMAXMASASMSMSMMMASMSSMMASASXXXMXXAMXXSMXMXSAAXXAMMSSMMMSMXSXAXAXMXMMAMASMSAAXMXAAAMXMSMMMXSMSMMSMMMXXS
+SMMSSXXMMSAMAMXXXMSSMAMMMMAMXSAASXMAXAAMSMXMSAMMAAAXXXAXAXAMAAMMMMMXSSSSSMAMSAAASXMSSXSAMAMSAMXAAMMSAMXSMMAMASAMSSMXMMMSMAAXMXSXSAAXMXSSSSMS
+MSAMXMXXAMXMXMXMXAAAXMASASAMAMMMMXSMSSSXMAMXMAXMMMMSAMXSMSMMMMMAAXAMMAAAXAMXAMMMSAMXAAMMSAMMAMSAMXXSXSXMASMMXSXMAXAAAMAAXXMXSMMAMSMXXAXXAAAM
+MMMSASXMASMMXMASMMSSMXSMASMMAMAAAXAMXXMMSAMXSMMXSAAMXMMAAXAAAMSSMXSAMMMMMSXXMXXXXAMMMXMASXXSAMXAXMAMXMASAMXXASXMMXSASMSMSMMMXAMMMMMSMMMMSMMM
+SAMMAMXAAMAAXSASAAXMMMMMAMAMASMSSSSMSMSASAMMAMXXXAMXASMMXMSMXMAMXMASXMAXMXMSXMSMMAMXMASAMMXSXSSMMSSMSXAMMSMMMSASXXXAMMMAXMAAMMXMASMXAAAMAXAX
+MXSMSSSSSSMMXMASMMMSASAMXSSMMMXAAAAAASMAMAMSMMSMMSMSMSAMSMXMXMASXXAMMSMSXMASMMAAMSSMMMMASMXSXMAAAAAAMMMMAAAAASAMXSMAMAMAXSXSAXXMAXXSMMXXMSXS
+SMXAMAMMAAAXXMAMAAASASASMAXMASMSMSMMMSMSMMMXAAXAAXAXAMAMXXAMASXMAMXSXAAAXMMSASMSMAAMXXSAMMAMMSSMMSMMMAAMSXSMXSAMAXMAMMMSMMAMXMXMXSXMSSSSMMMM
+AAMXMAMSSSMMSMASXMAXMSAMMMMMXSAXAXMAXMAAAASXMASMMMXMMSMMMXMSAMASXMAMXMSMXMMSAMAAMSMMXXMAMMAMAMAMAXAXSMSMMAMXAMAMASMXMXAAAMSMXMASAMXAAMMAMXAA
+MMMAXMMAXAAAMMMMXMASXMMMAMAMAMMMSMSSXMSMSMMAXAMXSXAXMAAAAMMMMSXMXMXMAMXAMSAMXMSMXXASMASAMSSSXSAMMSMMSAXAMSMMMSMMXMAAMMXMXAAAXSASXSMMMMSAMSSS
+SASXSSMXSSMMMSMMXAMXAAASASAMMMSAXAAAXXAMXAXMMXSASXSSSMSMXMAAXMMSMSAXASXAMMXSMMMMMSMXAXMAMAAAASAMXAMMMAMAMAMAMAMSMXSAMSASXSSSMSMSAMXSXASXXAMM
+SMSAAAXXXXAAXAAMSSXSMMMSASMSAAMSSMMSMSAMSMMMAXMASAXAMAXAASMMSAAAMAMSMMMSMXMAAAXAAAAXMMAMMMXMMSMSSSSXMXSSSMSASXMSAMXAXXAMAMAAAXAMAMAXXAMXMASA
+MAMMMMSMMMSSSSSMAMMAAAXMXMMMMSSMXXXMASXMAXAMAXMXMMMAMXMSMSAASMMSSMXAXXAMSMSSSMSMSSSMSMAMASAXXMAMAAAXMAMAAMSMSXMMSMSMMMAMAMMMMMMSXMMSSMMSSXMM
+MAMMXXAAXAAMAAXMASXSMMSAMXMMAXAMXSSMXMASASMSSMSASXMAMAAAXSMMSXAAAXSXSASAAMXMAXMAXAXAAMMSAAAMMMSMMMMXMAXMXMXSXASAMMAMXXMSXMXAXAMXAAAAAXAAMAXM
+SXSXMXSSMMSSMMMMXSXAMSAMSAMMSSXMASAMASXMAMAAAASAXXXMSASAAXAAXMMXXMMASMXSMSSSSMMSXSSSMSXMASMSMAXAMMSAMMSMAMXSMMMASMMSAMXMASMMMSASXMSSMMMSSSMS
+SAMAMXXAXAAMAAMSSMXXMXAXMAMSAMXMMMMMASMMSMMXMMMMMSMXMXMXMXMMMMXMSMMAMXXXXMMMXAAXMMAAXAXMAXAAMASAMAMXXXAXAXMMAMSXMAAXMMSMAMAAXMAXXXMAMXMXAMAA
+MASAMSSMMMSSMMMMAMSMSSMMMMMMMSXMAXMMXSAAXAAXMAXXAMAAMASAMSSSMMXAAAMSSSMSAXSAXMMMAMSMMMXMAMSMMXSXMAMSMSSSXXAXAMXXMMMMSASMSSMMMMXMAMSAMSSMAMSM
+XAMAMXAMXXAXAAAXMMAAXMSAASAXXMASASXSXSMMMMMAMMSMMSSMSASXXAAXASMSMXMMAAASAXMSSMSSSMMMAMXMSMMASAXMMMMAAAAXMASMSSSXSAAAMASXAMAAAAAAMMMMMAASXMXS
+MSSSMSSMMMMSSSMSSXMXMMXSMSAXXXAXAMXXASXSAMMSAMXXMAAAMASAMMSMMAAAAMSMSMMMXMAMXAAAXAASASAXMASXMAXSAMSMMMSMAXAAAAAASMSMMMMMSMXMMXSSMXAAMMMMMMAS
+XAAMMAMAMSXMAMAAXASASMMXXXMMSMMMSMSMMMAMAXAXMASXMMSMXAMMMXMMXMMMMMSAXXAXXMXSMMMSSSMSMXASMXMXMAXMAXAAAXXXSMXMMMMXMMMXSASAXASXSMAAASXSSSSXSMAS
+MMXMMAXAMMAMAMSMXSMAAAAMMSAAXAAXAAAAXMMMMMAXXMAMMXMMMSSXMXMASXSXSAMMMSSSMXMAMXXMAXAXAXSXMSSMMASAMSSSMSMMMAMXSASAMMMAMAMASXXAAMSMMMSAXXMASMAS
+MAASXMSXXSXMXXASMXMMMMSAAAMXSSXSMMMXMMMAASXSSSSSSMXAXAXXXSAMXMAMMASMAXXAAASXMASMAMMMMMXASAMXSMXAXMAMAAAAASAMSAXASAMAMAMASMMSMMMMXXXMMXMMMMAS
+XMAMAAAMMMMMMSAAXAXXAXXMAXMMMXAXMXSAAAMSMMAAMAXAAXMMSMSSMMSSSMMSSSMMASMMSMMAMXXMMSAAXAXMMAXASASMMMAMXMXMMXXAMSMMMASASAMXSAMXSAASAMAMXAMMAMAS
+MMSSMMMXAAXAAMMMSXXSMMXAAAXXMMSXMAMMSMMMSMMMMSMSMMSAAXAAXAAXAAAAMAAMAMAXAXSMMAMXASMSMSSXXSMASAAMXSSMXSMSSSXSAXMXSXMAXMMSXMMASMXXASAMSAMAXMAS
+MAXXXAAMSSMMMSAXXMASAASMMXSAXAMXMASXMMAAAXSAMXAXAAASMMSSMMMSXMMXSSSMXMSXMMAMXSMMXSAXAMXXAAMAMXMMAMXAXAAAASXMAXSAMAMAMSXXSAMXSXMSAMAXMAMSSMXS
+MSSSMMSMAAMAASXSSMMSAMSAAASMMAAMSAMXASMXMMMAXMSMMSMXXXAMMMXMAAMXAAAXMAMMSAMAAAAXSMMMXSASXMMASASMXXAMAMMMAMXMAMMAMXMAXSAXAXXAXAAAMMXMMAMXAMXM
+AAAXSAAMMMMMMXMSASAXASMMMMSXSXSAMXSSXMAASASXMAMXMMXXMMMSASAMMAXXMMMSASXAMASMSSMSASXAXMASMXMMMMMXMASXMXAXASAMMMSAMSMSMMMMMSAMMAMMSSSMSXXSAMAS
+MMSMMMMSASMMMSMSAMMSSMMMAMMMSMMAAMAMXMSMXASAAXSSXMXXXMAXXXAXASASASXMMXMSSXMMAAXXASMMXMMMAXSSSMSASXXAAXXSMMXMSAMXSAAAXAAAXXAXXXAXMAAXAMMSASAS
+SAXAXASXMSAAAAXMAMXXXAXSASAASASMMMSSMXAXMSMMSMMAAMMSMMSSSMSMMMAAASASMXMASAXMXSAMXMASXSMXSXAAAASASXSMMSASAMAAMASMMMSMSSSSSSMMMMMXMMMSMSASXMAS
+MASMMMXAXSMMSSSSSSSSMSMSXXMXXAMAAAAAASMSXAAAXXSSMMAASMMAMAAMXMXMSMAMMAMXMXMASXMAAXMMMXAAMMMMMXMXMASXSAASAMSMSAMAAMMAMXAXXXXAAAMXMXXAAMXSAMXM
+MMMXMMSSMMSMXAAAAXAXAXASXXMSMSMSMMSXXAMMMSXMMXAAXMSSSXMMMSMSMMMMXMXMSMMSXMASXMXSMSMXSXMMSAAXSSMMSAMXAMAMMMAAXXMXMSXMXSAMMSSSSMSAMXMMSSMMMSSM
+XSMXSAAAMAAMMMMMMMMMXMASXSAAAMAAXMAMMAAMAXAAXSSSMXMMMXXXAAXAXXAXXMAXMSASAMMAMAXASAXMMAMXXMMXMAAAMAMSMMAXASMSMSSSXMAMAMAMAMXAAASXMAXXAXAXAAAX
+XAAAMMSMMSXSAXAAXSAAXMXMAMSMMMAMXAAXXXMMASXMMMAAXAAAXMMSMSSSMSMMASXMAMXSASMMSSSMSMMMMAMXMSXXSSMMSAMMXSMSASAMAAAMSXAMAXAMSXMMMMXMSSSMSSSMMMSM
+MMMMXMXAXAMSMSMMMMASXXSMXMAMSXMMXMXMMSAMASMSSMMAMSSMMMXSMMAAAAASXMMMAMMMMMAAAAAASXSSXXXAMAMMMAMMMXSXAAAXAMAMSMMXXSXXXSSSXMAXXAXAMAAAAAAAXSXX
+AXAAAXXSMMXMAAAMAMSMMAAAMSMSMAXSAMAAMSAMXSAAXMXSXMAXAMAMAMSMMMMMAAMMXMAAASMMMSMMMAMAASMMSASXSAMAMASMSMAMMSXMXXXMMMMMMMMAMSXMMMMSSSMMMSMMMAAA
+SSSSMSAMXSASMSMMASMAXSMMMASAMXMSASXSASAMXMMMXSAMXSAXMMAMXMASXXXXSAMMSMSSMSAXAAXAMMMMMMAASMMMSASMMAXAAAAAAAXSXXSAAAAAAMMSMAMSXMAAMAXAAXASAMSM
+MAAAAMAMAMAMXAASXMMAMXXXSXSXSAASAMAMMSXMXSMAAMASAMXSXSSSMAXXMMXXMAAASAAMAMXMSSSXSXASAMXMMAAASXMXMMMSMSSSMMSAAMSSSSSSMSAAMASXAMMSSMMMXSXMSXAX
+MSMMMMMXAMAMMSMMAMMSXMAMMMSMSAXMMMAMXXMAMXMAMSAMAXXXMAXSAXMAXSASXSMASMMSSMAAXAXMSXSMSAMXSSMXSAAXXMAMAXAXASAMXMXAXMXXXMXSSMSMXMMAAXAXXMASXSSS