===================================================================
--- original.js
+++ change.js
@@ -593,12 +593,12 @@
 			case TileFormat.TYPES.VERTICAL:
 				// For vertical pipes, we flow in the opposite direction of incoming
 				// If water comes from top (π/2), we flow down
 				// If water comes from bottom (3π/2), we flow up
-				if (Math.abs(incomingDirection - Math.PI / 2) < 0.1) {
+				if (Math.abs(incomingDirection - 3 * Math.PI / 2) < 0.1) {
 					positions.push([col, row + 1]); // Flow down
 					log("VERTICAL: incoming from top, flowing down");
-				} else if (Math.abs(incomingDirection - 3 * Math.PI / 2) < 0.1) {
+				} else if (Math.abs(incomingDirection - Math.PI / 2) < 0.1) {
 					positions.push([col, row - 1]); // Flow up
 					log("VERTICAL: incoming from bottom, flowing up");
 				} else if (incomingDirection === 0) {
 					// Initial flow from start - flow down
@@ -619,8 +619,11 @@
 				}
 				break;
 			case TileFormat.TYPES.CORNER:
 				var normalizedRotation = (rotation + Math.PI / 2) % (2 * Math.PI);
+				log("CORNER PIE with rotation:", rotation, " normalized rotation:", normalizedRotation, " with incomping:", incomingDirection);
+				log("Checking if incoming match pipe entry");
+				log("if so, turn 90° or -90° depending on incoming and rotation...");
 				// For corner pipes, we turn 90° based on the incoming direction
 				var outgoingDirection;
 				// If incoming matches pipe entry point, turn 90° clockwise
 				if (Math.abs(incomingDirection - normalizedRotation) < 0.1) {
@@ -1108,9 +1111,10 @@
 		// Store start position
 		pathMap[startRow + "," + startCol] = {
 			row: startRow,
 			col: startCol,
-			flowDirection: startDir,
+			flowDirection: null,
+			// Start doesn't have incoming //startDir,
 			prevKey: null
 		};
 		while (toCheck.length > 0) {
 			var _toCheck$pop = toCheck.pop(),
@@ -1122,9 +1126,9 @@
 			if (visited.has(key)) {
 				continue;
 			}
 			visited.add(key);
-			log("Checking position - row:", row, "col:", col);
+			log("======================= Checking position - row:", row, "col:", col, "=========================");
 			// Store current position in path map
 			//pathMap.set(key, { row, col, flowDirection });
 			// Check if coordinates are within grid
 			if (row < 0 || row >= self.gridSize || col < 0 || col >= self.gridSize) {
@@ -1137,8 +1141,11 @@
 				continue;
 			}
 			var normalizedRotation = currentTile.normalizeRotation(currentTile.pipeContainer.rotation);
 			log("Checking tile:", currentTile.type, "rotation:", TileFormat.getRotationIndex(normalizedRotation));
+			if (currentTile.type == TileFormat.TYPES.START) {
+				flowDirection = null; // Start doesn't have incoming flow
+			}
 			var nextPositions = currentTile.getNextPositions(col, row, normalizedRotation, currentTile.type, flowDirection);
 			log("Next positions to check:", nextPositions);
 			var _iterator = _createForOfIteratorHelper(nextPositions),
 				_step;
@@ -1216,9 +1223,9 @@
 						log("Added end tile:", nextRow, nextCol);
 						log("Solution path reconstructed with", self.solutionPath.length, "tiles");
 						return true;
 					}
-					var nextFlowDirection = getFlowDirection(nextTile);
+					var nextFlowDirection = getFlowDirection(nextTile, incomingDirection);
 					var nextKey = nextRow + "," + nextCol;
 					toCheck.push([nextRow, nextCol, nextFlowDirection]);
 					pathMap[nextKey] = {
 						row: nextRow,
@@ -1436,25 +1443,26 @@
 initializeGame();
 /**** 
 * Helper Functions
 ****/ 
-function getFlowDirection(tile) {
-	var rotation = tile.normalizeRotation(tile.pipeContainer.rotation);
-	log("Tile type:", tile.type, "Rotation:", tile.pipeContainer.rotation, "Normalized rotation:", rotation);
+function getFlowDirection(tile, incomingDirection) {
+	//var rotation = tile.normalizeRotation(tile.pipeContainer.rotation);
+	var rotation = (incomingDirection + Math.PI) % (2 * Math.PI);
+	log("Tile type:", tile.type, "Rotation:", tile.pipeContainer.rotation, "incomingDirection:", incomingDirection, "Normalized incoming:", rotation);
 	switch (tile.type) {
 		case TileFormat.TYPES.START:
-			rotation += 3 * Math.PI / 2;
-			rotation = rotation % (2 * Math.PI);
-			log("Returned direction for START:", rotation);
-			return rotation;
+			rotation = tile.pipeContainer.rotation + 3 * Math.PI / 2;
+			break;
 		case TileFormat.TYPES.CORNER:
-			var cornerDirection = (rotation + Math.PI / 2) % (2 * Math.PI);
-			log("Returned direction for CORNER:", cornerDirection);
-			return cornerDirection;
+			rotation = (rotation + Math.PI / 2) % (2 * Math.PI);
+			break;
 		default:
-			log("Returned direction for default:", rotation);
-			return rotation;
+			rotation = rotation;
+			break;
 	}
+	rotation = rotation % (2 * Math.PI);
+	log("Returned flow direction:", rotation);
+	return rotation;
 }
 function canAcceptFlowFromDirection(tile, incomingDirection) {
 	var normalizedIncoming = (incomingDirection + Math.PI) % (2 * Math.PI);
 	var tileRotation = tile.normalizeRotation(tile.pipeContainer.rotation);