diff --git a/AoC_2025/Day06.cs b/AoC_2025/Day06.cs
index 7bc4bb0..c3ff020 100644
--- a/AoC_2025/Day06.cs
+++ b/AoC_2025/Day06.cs
@@ -38,14 +38,14 @@ public class Day06 : IPuzzleSolver<long>
         return results.Sum();
     }
 
-    private static long[] CalculateResults((Func<long, long, long> operation, long opBaseValue)[] operands, long[][] numbers)
+    private static long[] CalculateResults(Func<long, long, long>[] operands, long[][] numbers)
     {
         return operands
-            .Select((op, i) => numbers[i].Aggregate(op.opBaseValue, (acc, next) => op.operation(acc, next)))
+            .Select((operand, i) => numbers[i].Aggregate((acc, next) => operand(acc, next)))
             .ToArray();
     }
 
-    private (Func<long, long, long> operation, long opBaseValue)[] ParseOperands(string[] operands)
+    private Func<long, long, long>[] ParseOperands(string[] operands)
     {
         var parsedOperands = operands
             .Select(ParseOperand)
@@ -55,30 +55,45 @@ public class Day06 : IPuzzleSolver<long>
 
     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())
+        var splittedNUmbers = numbers
+            .Select(line => ParseLineByWhitespace(line))
+            .ToArray();
+        var parsedNumbers = splittedNUmbers
+            .Aggregate(Enumerable.Repeat(Array.Empty<long>(), splittedNUmbers[0].Length), 
+                (acc, line) => CombineLists(acc, line))
             .ToArray();
         return parsedNumbers;
     }
 
+    private static long[] ParseLineByWhitespace(string line)
+    {
+        return line.Split(' ', StringSplitOptions.RemoveEmptyEntries)
+            .Select(str => long.Parse(str))
+            .ToArray();
+    }
+
+    private static IEnumerable<long[]> CombineLists(IEnumerable<IEnumerable<long>> acc, IEnumerable<long> line)
+    {
+        return acc.Zip(line, (left, right) => (long[])[..left, right]);
+    }
+
     private static long[][] ParseNumbersByColumn(string[] numberLines)
     {
-        var (numberColumns, lastColumn) = Enumerable.Range(1, numberLines[0].Length)
-            .Select(i => numberLines.Aggregate("", (acc, numberLine) => acc + numberLine[^i]))
-            .Aggregate((columns: (List<long[]>)[[]], column: (long[])[]),
+        var combinedNumbers = numberLines
+            .Aggregate(Enumerable.Repeat(string.Empty, numberLines[0].Length),
+                (acc, line) => acc.Zip(line, (left, right) => left + right));
+        var (numberColumns, lastColumn) = combinedNumbers
+            .Aggregate((columns: new List<long[]>(), column: Array.Empty<long>()),
                 (acc, number) => string.IsNullOrWhiteSpace(number) 
                     ? ([..acc.columns, acc.column], []) 
                     : (acc.columns, [..acc.column, long.Parse(number)]));
-        return [lastColumn, ..Enumerable.Reverse(numberColumns)];
+        return [..numberColumns, lastColumn];
     }
 
-    private (Func<long, long, long> operation, long opBaseValue) ParseOperand(string operand) => operand switch
+    private Func<long, long, long> ParseOperand(string operand) => operand switch
     {
-        "+" => ((long a, long b) => a + b, 0),
-        "*" => ((long a, long b) => a * b, 1),
+        "+" => (long a, long b) => a + b,
+        "*" => (long a, long b) => a * b,
         _ => throw new ArgumentOutOfRangeException(nameof(operand))
     };
 }
\ No newline at end of file