===================================================================
--- original.js
+++ change.js
@@ -51,8 +51,72 @@
 ****/ 
 /**** 
 * Global level configurations
 ****/ 
+function _slicedToArray4(r, e) {
+	return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4();
+}
+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 _unsupportedIterableToArray4(r, a) {
+	if (r) {
+		if ("string" == typeof r) {
+			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) ? _arrayLikeToArray4(r, a) : void 0;
+	}
+}
+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 _iterableToArrayLimit4(r, l) {
+	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	if (null != t) {
+		var e,
+			n,
+			i,
+			u,
+			a = [],
+			f = !0,
+			o = !1;
+		try {
+			if (i = (t = t.call(r)).next, 0 === l) {
+				if (Object(t) !== t) {
+					return;
+				}
+				f = !1;
+			} else {
+				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
+					;
+				}
+			}
+		} catch (r) {
+			o = !0, n = r;
+		} finally {
+			try {
+				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
+					return;
+				}
+			} finally {
+				if (o) {
+					throw n;
+				}
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles4(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) {
@@ -1039,35 +1103,56 @@
 						continue;
 					}
 					if (nextTile.type === TileFormat.TYPES.END) {
 						log("Found path to end!");
-						// Reconstruct the solution path
+						// Start reconstruction from the end position
 						self.solutionPath = [];
-						var currentKey = key;
-						var visitedKeys = new SimpleSet(); // Track visited keys to prevent cycles
-						// Add the end tile to solution path first
+						var currentKey = nextRow + "," + nextCol;
+						var endTile = self.grid[nextRow][nextCol];
+						// First, add the end tile
 						self.solutionPath.unshift({
 							row: nextRow,
 							col: nextCol,
-							flowDirection: nextTile.normalizeRotation(nextTile.pipeContainer.rotation),
-							tile: nextTile
+							flowDirection: endTile.normalizeRotation(endTile.pipeContainer.rotation),
+							tile: endTile
 						});
-						// Then add all tiles from end back to start
-						while (currentKey && !visitedKeys.has(currentKey)) {
-							visitedKeys.add(currentKey);
-							var pos = pathMap[currentKey];
-							if (!pos) {
+						// 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: pos.row,
-								col: pos.col,
-								flowDirection: pos.flowDirection,
-								tile: self.grid[pos.row][pos.col]
+								row: currentRow,
+								col: currentCol,
+								flowDirection: currentTile.normalizeRotation(currentTile.pipeContainer.rotation),
+								tile: currentTile
 							});
-							currentKey = pos.prevKey;
+							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 length:", self.solutionPath.length);
+						log("Solution path reconstructed with", self.solutionPath.length, "tiles from", startRow + "," + startCol, "to", nextRow + "," + nextCol);
 						return true;
 					}
 					var nextFlowDirection = getFlowDirection(nextTile);
 					var nextKey = nextRow + "," + nextCol;
@@ -1188,27 +1273,62 @@
 		if (!self.solutionPath || self.solutionPath.length === 0) {
 			log("No solution path available!");
 			return false;
 		}
-		log("Starting water flow animation with path length:", self.solutionPath.length);
 		// Reset any existing flow states
 		for (var row = 0; row < self.gridSize; row++) {
 			for (var col = 0; col < self.gridSize; col++) {
 				if (self.grid[row][col]) {
 					self.grid[row][col].flow = false;
+					if (self.grid[row][col].water) {
+						self.grid[row][col].water.visible = false;
+					}
+					if (self.grid[row][col].waterV) {
+						self.grid[row][col].waterV.visible = false;
+					}
+					if (self.grid[row][col].waterH) {
+						self.grid[row][col].waterH.visible = false;
+					}
 				}
 			}
 		}
-		// Start the flow animation by following the stored path
-		for (var i = 0; i < self.solutionPath.length; i++) {
-			var pos = self.solutionPath[i];
-			if (!pos.tile) {
-				log("Warning: No tile found at position:", pos.row, pos.col);
-				continue;
+		self.waterFlowing = true;
+		log("Starting water flow through solution path:", self.solutionPath.length, "tiles");
+		var currentIndex = 0;
+		function animateNextTile() {
+			if (currentIndex >= self.solutionPath.length) {
+				// End of path reached - start end game sequence
+				LK.setTimeout(function () {
+					animateSoil();
+				}, 1000);
+				return;
 			}
-			log("Setting flow for tile at:", pos.row, pos.col, "type:", pos.tile.type);
-			pos.tile.flow = true;
+			var currentTile = self.solutionPath[currentIndex].tile;
+			currentTile.flow = true;
+			// Show appropriate water animation based on tile type
+			if (currentTile.water) {
+				currentTile.water.visible = true;
+			}
+			if (currentTile.waterV) {
+				currentTile.waterV.visible = true;
+			}
+			if (currentTile.waterH) {
+				currentTile.waterH.visible = true;
+				// Set water flow direction based on path
+				if (currentIndex > 0) {
+					var prevTile = self.solutionPath[currentIndex - 1].tile;
+					currentTile.waterH.scaleX = prevTile.gridCol < currentTile.gridCol ? 1 : -1;
+				}
+			}
+			// Special handling for end tile
+			if (currentTile.type === TileFormat.TYPES.END) {
+				createWaterDrops(currentTile.x, currentTile.y + 100, game);
+			}
+			currentIndex++;
+			LK.setTimeout(animateNextTile, 300);
 		}
+		// Start the animation
+		animateNextTile();
 		return true;
 	};
 	return this;
 };
@@ -1284,9 +1404,9 @@
 	var alphaIncrement = 0.05; // Adjust the increment for desired speed
 	// Animate all baseTile tiles' alpha from 1 to 0
 	puzzleManager.grid.forEach(function (row) {
 		row.forEach(function (tile) {
-			if (tile.baseTile) {
+			if (tile && tile.baseTile) {
 				tile.baseTile.alpha = 1;
 				LK.setInterval(function () {
 					if (tile.baseTile.alpha > 0) {
 						tile.baseTile.alpha -= alphaIncrement;