===================================================================
--- original.js
+++ change.js
@@ -51,31 +51,31 @@
 ****/ 
 /**** 
 * Global level configurations
 ****/ 
-function _slicedToArray4(r, e) {
-	return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4();
+function _slicedToArray2(r, e) {
+	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
 }
-function _nonIterableRest4() {
+function _nonIterableRest2() {
 	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _unsupportedIterableToArray4(r, a) {
+function _unsupportedIterableToArray2(r, a) {
 	if (r) {
 		if ("string" == typeof r) {
-			return _arrayLikeToArray4(r, a);
+			return _arrayLikeToArray2(r, a);
 		}
 		var t = {}.toString.call(r).slice(8, -1);
-		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0;
+		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
 	}
 }
-function _arrayLikeToArray4(r, a) {
+function _arrayLikeToArray2(r, a) {
 	(null == a || a > r.length) && (a = r.length);
 	for (var e = 0, n = Array(a); e < a; e++) {
 		n[e] = r[e];
 	}
 	return n;
 }
-function _iterableToArrayLimit4(r, l) {
+function _iterableToArrayLimit2(r, l) {
 	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
 	if (null != t) {
 		var e,
 			n,
@@ -110,86 +110,36 @@
 		}
 		return a;
 	}
 }
-function _arrayWithHoles4(r) {
+function _arrayWithHoles2(r) {
 	if (Array.isArray(r)) {
 		return r;
 	}
 }
-function _createForOfIteratorHelper(r, e) {
-	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-	if (!t) {
-		if (Array.isArray(r) || (t = _unsupportedIterableToArray2(r)) || e && r && "number" == typeof r.length) {
-			t && (r = t);
-			var _n = 0,
-				F = function F() {};
-			return {
-				s: F,
-				n: function n() {
-					return _n >= r.length ? {
-						done: !0
-					} : {
-						done: !1,
-						value: r[_n++]
-					};
-				},
-				e: function e(r) {
-					throw r;
-				},
-				f: F
-			};
-		}
-		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-	}
-	var o,
-		a = !0,
-		u = !1;
-	return {
-		s: function s() {
-			t = t.call(r);
-		},
-		n: function n() {
-			var r = t.next();
-			return a = r.done, r;
-		},
-		e: function e(r) {
-			u = !0, o = r;
-		},
-		f: function f() {
-			try {
-				a || null == t["return"] || t["return"]();
-			} finally {
-				if (u) {
-					throw o;
-				}
-			}
-		}
-	};
+function _slicedToArray4(r, e) {
+	return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4();
 }
-function _slicedToArray2(r, e) {
-	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
-}
-function _nonIterableRest2() {
+function _nonIterableRest4() {
 	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _unsupportedIterableToArray2(r, a) {
+function _unsupportedIterableToArray4(r, a) {
 	if (r) {
 		if ("string" == typeof r) {
-			return _arrayLikeToArray2(r, a);
+			return _arrayLikeToArray4(r, a);
 		}
 		var t = {}.toString.call(r).slice(8, -1);
-		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
+		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0;
 	}
 }
-function _arrayLikeToArray2(r, a) {
+function _arrayLikeToArray4(r, a) {
 	(null == a || a > r.length) && (a = r.length);
 	for (var e = 0, n = Array(a); e < a; e++) {
 		n[e] = r[e];
 	}
 	return n;
 }
-function _iterableToArrayLimit2(r, l) {
+function _iterableToArrayLimit4(r, l) {
 	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
 	if (null != t) {
 		var e,
 			n,
@@ -224,9 +174,9 @@
 		}
 		return a;
 	}
 }
-function _arrayWithHoles2(r) {
+function _arrayWithHoles4(r) {
 	if (Array.isArray(r)) {
 		return r;
 	}
 }
@@ -1066,54 +1016,34 @@
 					if (nextTile.type === TileFormat.TYPES.END) {
 						log("Found path to end!");
 						// Start reconstruction from the end position
 						self.solutionPath = [];
-						var currentKey = nextRow + "," + nextCol;
-						var endTile = self.grid[nextRow][nextCol];
-						// First, add the end tile
-						self.solutionPath.unshift({
+						// Add all tiles from pathMap to solution path
+						Object.keys(pathMap).forEach(function (key) {
+							var _key$split$map = key.split(",").map(Number),
+								_key$split$map2 = _slicedToArray5(_key$split$map, 2),
+								row = _key$split$map2[0],
+								col = _key$split$map2[1];
+							var tile = self.grid[row][col];
+							if (tile) {
+								self.solutionPath.push({
+									row: row,
+									col: col,
+									flowDirection: tile.normalizeRotation(tile.pipeContainer.rotation),
+									tile: tile
+								});
+								log("Added tile from pathMap:", row, col);
+							}
+						});
+						// Add the end tile
+						self.solutionPath.push({
 							row: nextRow,
 							col: nextCol,
-							flowDirection: endTile.normalizeRotation(endTile.pipeContainer.rotation),
-							tile: endTile
+							flowDirection: nextTile.normalizeRotation(nextTile.pipeContainer.rotation),
+							tile: nextTile
 						});
-						// Log the initial state before entering the loop
-						log("Starting path reconstruction from end tile at", nextRow, nextCol);
-						log("Initial pathMap:", pathMap);
-						log("Initial currentKey:", currentKey);
-						// Then work backwards through pathMap to the start
-						while (currentKey) {
-							var _currentKey$split$map = currentKey.split(",").map(Number),
-								_currentKey$split$map2 = _slicedToArray4(_currentKey$split$map, 2),
-								currentRow = _currentKey$split$map2[0],
-								currentCol = _currentKey$split$map2[1];
-							var currentTile = self.grid[currentRow][currentCol];
-							if (!currentTile) {
-								log("No tile found at", currentRow, currentCol, "- breaking loop");
-								break;
-							}
-							self.solutionPath.unshift({
-								row: currentRow,
-								col: currentCol,
-								flowDirection: currentTile.normalizeRotation(currentTile.pipeContainer.rotation),
-								tile: currentTile
-							});
-							log("Added tile at", currentRow, currentCol, "to solution path");
-							// Check for reaching the start tile
-							if (currentRow === startRow && currentCol === startCol) {
-								log("Reached start tile at", startRow, startCol);
-								break;
-							}
-							// Move to previous tile in path
-							var pathInfo = pathMap[currentKey];
-							if (!pathInfo || !pathInfo.prevKey) {
-								log("No previous key found for", currentKey, "- breaking loop");
-								break;
-							}
-							currentKey = pathInfo.prevKey;
-							log("Moving to previous key:", currentKey);
-						}
-						log("Solution path reconstructed with", self.solutionPath.length, "tiles from", startRow + "," + startCol, "to", nextRow + "," + nextCol);
+						log("Added end tile:", nextRow, nextCol);
+						log("Solution path reconstructed with", self.solutionPath.length, "tiles");
 						return true;
 					}
 					var nextFlowDirection = getFlowDirection(nextTile);
 					var nextKey = nextRow + "," + nextCol;