===================================================================
--- original.js
+++ change.js
@@ -352,9 +352,9 @@
 				x: -65,
 				y: -65
 			}
 		});
-		return configs[self.normalizedRotation] || configs[0];
+		return configs[self.normalizeRotation(self.pipeContainer.rotation)] || configs[0];
 	};
 	self.updateCornerPipeFirstPhase = function (progress, thirdSize) {
 		log("Progress in first third:", progress);
 		var config = self.getCornerPipeConfig();
@@ -1392,33 +1392,38 @@
 		});
 		self.initPuzzle();
 	};
 	self.checkWinCondition = function () {
-		// Find start position
-		log("=== Starting Win Condition Check ===");
-		log("Grid state:");
-		for (var i = 0; i < self.gridSize; i++) {
-			var row = [];
-			for (var j = 0; j < self.gridSize; j++) {
-				var tile = self.grid[i][j];
-				row.push(tile ? "".concat(tile.type, "(").concat(tile.rotation, ")") : 'empty');
+		// Find start tile properly
+		var startTile = null;
+		var startX = -1,
+			startY = -1;
+		for (var y = 0; y < self.gridSize; y++) {
+			for (var x = 0; x < self.gridSize; x++) {
+				if (self.grid[y][x] && self.grid[y][x].type === 'start') {
+					startTile = self.grid[y][x];
+					startX = x;
+					startY = y;
+					break;
+				}
 			}
-			log("Row " + i + ":", row.join(' | '));
+			if (startTile) {
+				break;
+			}
 		}
+		if (!startTile) {
+			log("No start tile found!");
+			return false;
+		}
+		log("Found start tile at:", startX, startY);
 		var visited = new SimpleSet();
-		var startTile = self.grid.find(function (row) {
-			return row.find(function (tile) {
-				return tile.type === 'start';
-			});
-		})[0];
-		var toCheck = [[startTile.gridX, startTile.gridY, getFlowDirection(startTile)]];
+		var toCheck = [[startX, startY, getFlowDirection(startTile)]];
 		function getFlowDirection(tile) {
 			// Returns the direction the water flows out of this tile
-			var rotation = tile.normalizedRotation || tile.normalizeRotation(tile.pipeContainer.rotation);
+			var rotation = tile.normalizeRotation(tile.pipeContainer.rotation);
 			switch (tile.type) {
 				case 'start':
 					return rotation;
-				// Start tile flows in the direction it points
 				case 'cornerPipe':
 					// Corner pipe changes flow direction by 90 degrees
 					return (rotation + Math.PI / 2) % (2 * Math.PI);
 				default:
@@ -1428,18 +1433,17 @@
 		function canAcceptFlowFromDirection(tile, incomingDirection) {
 			// incomingDirection is the direction the water is coming FROM
 			// Need to normalize it to match the tile's rotation
 			var normalizedIncoming = (incomingDirection + Math.PI) % (2 * Math.PI);
-			var tileRotation = tile.normalizedRotation || tile.normalizeRotation(tile.pipeContainer.rotation);
+			var tileRotation = tile.normalizeRotation(tile.pipeContainer.rotation);
 			switch (tile.type) {
 				case 'start':
-					// Start tile only outputs, doesn't accept flow
 					return false;
+				// Start tile only outputs
 				case 'end':
 					// End tile only accepts flow from its rotated direction
 					var angle = (normalizedIncoming - tileRotation + 2 * Math.PI) % (2 * Math.PI);
 					return angle < 0.1;
-				// Only accept flow from the direction it points
 				case 'straightPipeV':
 					// Vertical pipe only accepts flow from top (π/2) or bottom (3π/2)
 					var angle = Math.abs(normalizedIncoming - Math.PI / 2) % (2 * Math.PI);
 					return angle < 0.1 || Math.abs(angle - Math.PI) < 0.1;
@@ -1448,9 +1452,8 @@
 					var angle = normalizedIncoming % (2 * Math.PI);
 					return angle < 0.1 || Math.abs(angle - Math.PI) < 0.1;
 				case 'cornerPipe':
 					// Corner pipe accepts flow from two adjacent directions based on rotation
-					// It accepts flow from the direction it points and 90 degrees CCW from that
 					var angle = (normalizedIncoming - tileRotation + 2 * Math.PI) % (2 * Math.PI);
 					return angle < 0.1 || Math.abs(angle - Math.PI / 2) < 0.1;
 				default:
 					return false;
@@ -1468,49 +1471,43 @@
 			}
 			visited.add(key);
 			log("Checking position:", x, y);
 			if (x < 0 || x >= self.gridSize || y < 0 || y >= self.gridSize) {
+				log("Position out of bounds");
 				continue;
 			}
-			if (x < 0 || x >= self.gridSize || y < 0 || y >= self.gridSize) {
-				continue;
-			}
-			if (y < 0 || y >= self.gridSize || x < 0 || x >= self.gridSize) {
-				continue;
-			}
-			var currentTile = self.grid[y] ? self.grid[y][x] : undefined;
+			var currentTile = self.grid[y][x];
 			if (!currentTile) {
+				log("No tile at position");
 				continue;
 			}
-			var normalizedRotation = currentTile.normalizedRotation || currentTile.normalizeRotation(currentTile.pipeContainer.rotation);
+			var normalizedRotation = currentTile.normalizeRotation(currentTile.pipeContainer.rotation);
 			log("Checking tile:", currentTile.type, "with normalized rotation:", normalizedRotation, "at position:", x, y);
-			// Get next positions based on current tile type and rotation
 			var nextPositions = currentTile.getNextPositions(x, y, currentTile.type, normalizedRotation);
 			log("Next positions to check:", nextPositions);
 			for (var i = 0; i < nextPositions.length; i++) {
 				var _nextPositions$i = _slicedToArray3(nextPositions[i], 2),
 					nextX = _nextPositions$i[0],
 					nextY = _nextPositions$i[1];
-				log("Trying next position:", nextPositions[i]);
+				log("Trying next position:", nextX, nextY);
 				if (nextX < 0 || nextX >= self.gridSize || nextY < 0 || nextY >= self.gridSize) {
+					log("Next position out of bounds");
 					continue;
 				}
 				var nextTile = self.grid[nextY][nextX];
 				if (!nextTile) {
+					log("No tile at next position");
 					continue;
 				}
-				// Calculate the direction the flow is coming from for the next tile
 				var incomingDirection = Math.atan2(nextY - y, nextX - x);
-				// Check if the next tile can accept flow from this direction
 				if (!canAcceptFlowFromDirection(nextTile, incomingDirection)) {
 					log("Tile at", nextX, nextY, "cannot accept flow from direction", incomingDirection);
 					continue;
 				}
 				if (nextTile.type === 'end') {
 					log("Found path to end!");
 					return true;
 				}
-				// Calculate the direction of flow out of the next tile
 				var nextFlowDirection = getFlowDirection(nextTile);
 				toCheck.push([nextX, nextY, nextFlowDirection]);
 			}
 		}