diff --git a/AoC_2025/Day06.cs b/AoC_2025/Day06.cs
index 38dfbda..1f3d299 100644
--- a/AoC_2025/Day06.cs
+++ b/AoC_2025/Day06.cs
@@ -2,13 +2,12 @@
 using System.IO;
 using System.Linq;
 using AdvenOfCode.Contracts;
-using Coordinate = (int x, int y);
 
 namespace AoC_2025;
 
 public class Day06 : IPuzzleSolver<long>
 {
-    private (string[] operands, string[] numbers) ParsePuzzleInput(string path)
+    private (string[] operands, string[] numberLines) ParsePuzzleInput(string path)
     {
         var puzzleInput = File.ReadAllLines(path)
             .Where(line => !string.IsNullOrWhiteSpace(line))
@@ -22,49 +21,70 @@ public class Day06 : IPuzzleSolver<long>
     public long SolvePart1(string pathToPuzzleInput)
     {
         var calculations = ParsePuzzleInput(pathToPuzzleInput);
-        var numbers = calculations.numbers
-            .Select(line => line.Split(' ', StringSplitOptions.RemoveEmptyEntries))
-            .Select(line => line.Index())
-            .SelectMany(tuples => tuples.Select(tuple => (tuple.Index, long.Parse(tuple.Item))))
-            .ToArray();
-        var pivotedNumbers = numbers.GroupBy(tuple => tuple.Index);
-        var indexedOperands = calculations.operands
-            .Index()
-            .Select(tuple => (tuple.Index, ParseOperand(tuple.Item)))
-            .ToDictionary();
-        var results = pivotedNumbers.Select(group =>
-            group
-                .Select(tuple => tuple.Item2)
-                .Aggregate(indexedOperands[group.Key].opBaseValue,
-                    (acc, number) => indexedOperands[group.Key].operation(acc, number)));
+        var numbers = ParseNumbersByWhitespace(calculations.numberLines);
+        var operands = ParseOperands(calculations.operands);
+        var results = CalculateResults(operands, numbers);
         return results.Sum();
     }
     
     public long SolvePart2(string pathToPuzzleInput)
     {
         var calculations = ParsePuzzleInput(pathToPuzzleInput);
-        var operands = calculations.operands.Select(ParseOperand).Reverse().ToArray();
-        List<List<long>> numberColumns = [];
-        List<long> currentColumn = [];
-        for (var i = 1; i <= calculations.numbers[0].Length; i++)
-        {
-            var current = calculations.numbers.Aggregate("", (current1, number) => current1 + number[^i]);
+        var operands = ParseOperands(calculations.operands);
+        var numbers = ParseNumbersByColumn(calculations.numberLines);
+        var results = CalculateResults(operands, numbers);
 
-            if (!string.IsNullOrWhiteSpace(current))
+        return results.Sum();
+    }
+
+    private static long[] CalculateResults((Func<long, long, long> operation, long opBaseValue)[] operands, long[][] numbers)
+    {
+        return operands
+            .Select((op, i) => numbers[i].Aggregate(op.opBaseValue, (acc, next) => op.operation(acc, next)))
+            .ToArray();
+    }
+
+    private (Func<long, long, long> operation, long opBaseValue)[] ParseOperands(string[] operands)
+    {
+        var parsedOperands = operands
+            .Select(ParseOperand)
+            .ToArray();
+        return parsedOperands;
+    }
+
+    private static long[][] ParseNumbersByWhitespace(string[] numbers)
+    {
+        var parsedNumbers = numbers
+            .Select(line => line.Split(' ', StringSplitOptions.RemoveEmptyEntries))
+            .SelectMany(line => line.Select(long.Parse).Index())
+            .GroupBy(indexedNumber => indexedNumber.Index)
+            .Select(group => group.Select(indexedNumber => indexedNumber.Item).ToArray())
+            .ToArray();
+        return parsedNumbers;
+    }
+
+    private static long[][] ParseNumbersByColumn(string[] numberLines)
+    {
+        List<long[]> numberColumns = [];
+        List<long> currentColumn = [];
+        for (var i = 1; i <= numberLines[0].Length; i++)
+        {
+            var nextNumber = numberLines.Aggregate("", (acc, numberLine) => acc + numberLine[^i]);
+
+            if (!string.IsNullOrWhiteSpace(nextNumber))
             {
-                currentColumn.Add(long.Parse(current));
+                currentColumn.Add(long.Parse(nextNumber));
             }
             else
             {
-                numberColumns.Add(currentColumn);
+                numberColumns.Add(currentColumn.ToArray());
                 currentColumn = [];
             }
         }
-        numberColumns.Add(currentColumn);
-
-        return numberColumns
-            .Select((column, colIndex) => column.Aggregate(operands[colIndex].opBaseValue, (acc, next) => operands[colIndex].operation(acc, next)))
-            .Sum();
+        numberColumns.Add(currentColumn.ToArray());
+        
+        numberColumns.Reverse();
+        return numberColumns.ToArray();
     }
 
     private (Func<long, long, long> operation, long opBaseValue) ParseOperand(string operand) => operand switch