diff --git a/2024/day4/src/main.rs b/2024/day4/src/main.rs
index e7d7543..8127a9c 100644
--- a/2024/day4/src/main.rs
+++ b/2024/day4/src/main.rs
@@ -1,14 +1,21 @@
-use std::{fs, isize};
+use std::{fs, time::Instant};
 
 fn main() {
     let file = fs::read_to_string("./input.txt").unwrap();
-    let grid = file.lines().collect::<Vec<&str>>();
+    let grid = file.lines().map(|l| l.as_bytes()).collect::<Vec<&[u8]>>();
 
+    let start = Instant::now();
     println!("Solution 1: {}", puzzle1(&grid));
+    let time = Instant::now() - start;
+    println!("Solution 1 time: {}", time.as_micros());
+
+    let start = Instant::now();
     println!("Solution 2: {}", puzzle2(&grid));
+    let time = Instant::now() - start;
+    println!("Solution 2 time: {}", time.as_micros());
 }
 
-fn puzzle1(grid: &[&str]) -> i32 {
+fn puzzle1(grid: &[&[u8]]) -> i32 {
     let mut count = 0;
 
     let glen = grid.len() as isize;
@@ -31,21 +38,12 @@ fn puzzle1(grid: &[&str]) -> i32 {
                 let ymul = y + 3 * dy;
                 let xmul = x + 3 * dx;
 
-                if 0 <= ymul && ymul < glen && 0 <= xmul && xmul < glen {
-                    let gridx = grid[y as usize].chars().nth(x as usize).unwrap();
-                    let gridm = grid[(y + dy) as usize]
-                        .chars()
-                        .nth((x + dx) as usize)
-                        .unwrap();
-                    let grida = grid[(y + 2 * dy) as usize]
-                        .chars()
-                        .nth((x + 2 * dx) as usize)
-                        .unwrap();
-                    let grids = grid[(y + 3 * dy) as usize]
-                        .chars()
-                        .nth((x + 3 * dx) as usize)
-                        .unwrap();
-                    if gridx == 'X' && gridm == 'M' && grida == 'A' && grids == 'S' {
+                if 0 <= ymul && ymul < glen && 0 <= xmul && xmul < xlen {
+                    let gridx = grid[y as usize][x as usize];
+                    let gridm = grid[(y + dy) as usize][(x + dx) as usize];
+                    let grida = grid[(y + 2 * dy) as usize][(x + 2 * dx) as usize];
+                    let grids = grid[(y + 3 * dy) as usize][(x + 3 * dx) as usize];
+                    if gridx == b'X' && gridm == b'M' && grida == b'A' && grids == b'S' {
                         count += 1;
                     }
                 }
@@ -56,7 +54,7 @@ fn puzzle1(grid: &[&str]) -> i32 {
     count
 }
 
-fn puzzle2(grid: &[&str]) -> i32 {
+fn puzzle2(grid: &[&[u8]]) -> i32 {
     let mut count = 0;
 
     let glen = grid.len();
@@ -68,27 +66,27 @@ fn puzzle2(grid: &[&str]) -> i32 {
                 continue;
             }
 
-            let gridstart = grid[y].chars().nth(x).unwrap();
-            let gridmid = grid[y + 1].chars().nth(x + 1).unwrap();
-            let gridbotright = grid[y + 2].chars().nth(x + 2).unwrap();
-            let gridbotleft = grid[y + 2].chars().nth(x).unwrap();
-            let gridupright = grid[y].chars().nth(x + 2).unwrap();
+            let gridstart = grid[y][x];
+            let gridmid = grid[y + 1][x + 1];
+            let gridbotright = grid[y + 2][x + 2];
+            let gridbotleft = grid[y + 2][x];
+            let gridupright = grid[y][x + 2];
 
             match gridstart {
-                'M' => {
-                    if gridmid == 'A'
-                        && gridbotright == 'S'
-                        && (gridbotleft == 'M' && gridupright == 'S'
-                            || gridbotleft == 'S' && gridupright == 'M')
+                b'M' => {
+                    if gridmid == b'A'
+                        && gridbotright == b'S'
+                        && (gridbotleft == b'M' && gridupright == b'S'
+                            || gridbotleft == b'S' && gridupright == b'M')
                     {
                         count += 1;
                     }
                 }
-                'S' => {
-                    if gridmid == 'A'
-                        && gridbotright == 'M'
-                        && (gridbotleft == 'M' && gridupright == 'S'
-                            || gridbotleft == 'S' && gridupright == 'M')
+                b'S' => {
+                    if gridmid == b'A'
+                        && gridbotright == b'M'
+                        && (gridbotleft == b'M' && gridupright == b'S'
+                            || gridbotleft == b'S' && gridupright == b'M')
                     {
                         count += 1;
                     }