===================================================================
--- original.js
+++ change.js
@@ -63,34 +63,28 @@
 
 /**** 
 * Game Code
 ****/ 
-// Grid configuration
-// Cell pool for object reuse
 var cellPool = [];
-// Factory function to get a GridCell (from pool or new)
 function getGridCell() {
 	if (cellPool.length > 0) {
-		return cellPool.pop().init(); // Reuse a cell from the pool
+		return cellPool.pop().init();
 	}
-	return new GridCell(); // Create a new cell
+	return new GridCell();
 }
-// Function to return a cell to the pool
 function recycleGridCell(cell) {
 	if (cell) {
-		cellPool.push(cell); // Add to pool for later reuse
+		cellPool.push(cell);
 	}
 }
 var selectedCell = null;
 var isAnimating = false;
-// Additional animation flags to prevent race conditions
-window.gravityInProgress = false;
-window.fillInProgress = false;
-window.destructionInProgress = false;
-window.pendingDestructions = [];
+var gravityInProgress = false;
+var fillInProgress = false;
+var destructionInProgress = false;
+var pendingDestructions = [];
 function handleCellTap(tappedCell) {
-	// Check all animation flags to ensure no animations are in progress
-	if (isAnimating || window.gravityInProgress || window.fillInProgress || window.destructionInProgress) {
+	if (isAnimating || gravityInProgress || fillInProgress || destructionInProgress) {
 		return;
 	}
 	if (selectedCell === null) {
 		selectedCell = tappedCell;
@@ -106,28 +100,22 @@
 	if (!isAdjacent) {
 		selectedCell = tappedCell;
 		return;
 	}
-	// Case 5: Adjacent cell - perform the swap
-	// Store original positions for animation
 	var pos1_x = cell1.x;
 	var pos1_y = cell1.y;
 	var pos2_x = cell2.x;
 	var pos2_y = cell2.y;
-	// Store original grid indices
 	var row1 = cell1.row;
 	var col1 = cell1.col;
 	var row2 = cell2.row;
 	var col2 = cell2.col;
-	// Swap cells in the gridCells array
 	gridCells[row1][col1] = cell2;
 	gridCells[row2][col2] = cell1;
-	// Swap row/col properties on the cell objects
 	cell1.row = row2;
 	cell1.col = col2;
 	cell2.row = row1;
 	cell2.col = col1;
-	// Animate the visual swap of positions
 	tween(cell1, {
 		x: pos2_x,
 		y: pos2_y
 	}, {
@@ -138,291 +126,219 @@
 		y: pos1_y
 	}, {
 		duration: 300
 	});
-	selectedCell = null; // Reset selection after swap
-	// Schedule the match check and destruction slightly after the animation completes
+	selectedCell = null;
 	LK.setTimeout(function () {
-		checkForAndDestroyMatches(cell1, cell2); // Pass the swapped cells
-		// Future enhancement: After destruction, new cells might fall,
-		// and new matches could form. This would require a loop of:
-		// check/destroy -> fill -> check/destroy ... until no more matches.
-		// For now, we just check once after the swap.
-	}, 350); // Animation is 300ms, add a small buffer of 50ms
+		checkForAndDestroyMatches(cell1, cell2);
+	}, 350);
 }
 // Helper functions for match detection and destruction
 function getMatches() {
 	var matches = [];
-	// Helper function to find matches in a specific direction
 	function findDirectionalMatches(isHorizontal) {
 		var primary, secondary;
 		var primaryMax = isHorizontal ? gridSize + extraRows : gridSize;
 		var secondaryMax = isHorizontal ? gridSize : gridSize + extraRows;
-		// Only check visible grid plus extra rows above
 		for (primary = isHorizontal ? extraRows : 0; primary < primaryMax; primary++) {
 			for (secondary = 0; secondary < secondaryMax;) {
-				// Skip if not enough cells left for a match of 3
 				if (secondary > secondaryMax - 3) {
 					secondary++;
 					continue;
 				}
-				// Get current cell based on direction
 				var cell1 = isHorizontal ? gridCells[primary][secondary] : gridCells[secondary][primary];
 				if (!cell1) {
-					// Skip empty cells
 					secondary++;
 					continue;
 				}
 				var currentMatchValue = cell1.value;
 				var currentMatchCells = [cell1];
-				// Check subsequent cells for matches
 				for (var k = secondary + 1; k < secondaryMax; k++) {
 					var nextCell = isHorizontal ? gridCells[primary][k] : gridCells[k][primary];
 					if (nextCell && nextCell.value === currentMatchValue) {
 						currentMatchCells.push(nextCell);
 					} else {
-						break; // End of current potential match
+						break;
 					}
 				}
-				// Add to matches if we found 3 or more
 				if (currentMatchCells.length >= 3) {
 					matches.push(currentMatchCells);
 				}
-				// Move index forward based on match length
 				secondary += currentMatchCells.length > 0 ? currentMatchCells.length : 1;
 			}
 		}
 	}
-	// Find horizontal matches
 	findDirectionalMatches(true);
-	// Find vertical matches
 	findDirectionalMatches(false);
 	return matches;
 }
 function destroyCells(cellsToDestroy) {
-	// Set animation flag to prevent user interaction during destruction
 	isAnimating = true;
-	// Check if we're already processing destruction
-	if (window.destructionInProgress) {
-		// Queue this destruction for later instead of running now
-		if (!window.pendingDestructions) {
-			window.pendingDestructions = [];
+	if (destructionInProgress) {
+		if (!pendingDestructions) {
+			pendingDestructions = [];
 		}
-		window.pendingDestructions.push(cellsToDestroy);
+		pendingDestructions.push(cellsToDestroy);
 		return;
 	}
-	window.destructionInProgress = true;
-	// Filter to only include cells in the visible grid (not in the extra rows)
+	destructionInProgress = true;
 	var visibleCellsToDestroy = cellsToDestroy.filter(function (cell) {
 		return cell.row >= extraRows;
 	});
-	// Process each cell with a slight delay for more satisfying destruction
 	var delay = 0;
-	var delayIncrement = 100; // 100ms delay between each meme destruction
-	// Calculate total destruction time for this sequence only
+	var delayIncrement = 100;
 	var totalDestructionTime = visibleCellsToDestroy.length * delayIncrement;
 	visibleCellsToDestroy.forEach(function (cell) {
-		// Schedule destruction with increasing delay
 		LK.setTimeout(function () {
-			// Defensive checks: ensure cell exists and is the one we expect in the grid
 			if (cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
-				// Play explosion sound
 				LK.getSound('Explosion').play();
-				// Visual flash effect
 				LK.effects.flashObject(cell, 0xFFFFFF, 200);
-				// Remove from display
 				gridContainer.removeChild(cell);
-				cell.destroy(); // Destroy the cell object (releases resources)
-				gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
+				cell.destroy();
+				gridCells[cell.row][cell.col] = null;
 			}
 		}, delay);
-		// Increase delay for next cell
 		delay += delayIncrement;
 	});
-	// After destroying cells, make memes fall to fill empty spaces
-	// Wait until all cells are destroyed using the exact time for this sequence
 	LK.setTimeout(function () {
-		window.destructionInProgress = false;
-		// Check for pending destructions before applying gravity
-		if (window.pendingDestructions && window.pendingDestructions.length > 0) {
-			var nextDestructions = window.pendingDestructions.shift();
+		destructionInProgress = false;
+		if (pendingDestructions && pendingDestructions.length > 0) {
+			var nextDestructions = pendingDestructions.shift();
 			LK.setTimeout(function () {
 				destroyCells(nextDestructions);
 			}, 50);
 			return;
 		}
 		applyGravity();
-	}, totalDestructionTime + 50); // Use exact time based on this destruction sequence
+	}, totalDestructionTime + 50);
 }
 // Function to make memes fall down to fill empty spaces
 function applyGravity() {
-	// Set animation flag to prevent user interaction
 	isAnimating = true;
-	// Track all cells that need to fall for sequencing
 	var cellsToFall = [];
-	// Track if we're already processing gravity to prevent multiple calls
-	if (window.gravityInProgress) {
+	if (gravityInProgress) {
 		return;
 	}
-	window.gravityInProgress = true;
-	// First pass: identify all cells that need to fall
+	gravityInProgress = true;
 	for (var col = 0; col < gridSize; col++) {
-		// Start from the bottom row and work upwards
 		for (var row = gridSize + extraRows - 1; row >= extraRows; row--) {
-			// If current cell is empty
 			if (!gridCells[row][col]) {
-				// Look for the nearest non-empty cell above
 				var sourceRow = row - 1;
 				while (sourceRow >= 0 && !gridCells[sourceRow][col]) {
 					sourceRow--;
 				}
-				// If we found a cell to move down
 				if (sourceRow >= 0) {
 					var cellToMove = gridCells[sourceRow][col];
-					// Store the cell along with destination info
 					cellsToFall.push({
 						cell: cellToMove,
 						fromRow: sourceRow,
 						toRow: row,
 						col: col
 					});
-					// Update grid array
 					gridCells[row][col] = cellToMove;
 					gridCells[sourceRow][col] = null;
-					// Update cell's logical position
 					cellToMove.row = row;
-					// Add the cell to the grid container if it was previously hidden
 					if (sourceRow < extraRows) {
 						gridContainer.addChild(cellToMove);
 					}
 				}
 			}
 		}
 	}
-	// Second pass: animate falls with sequential delays
 	var longestDelay = 0;
-	var baseDelay = 30; // Base delay in ms between each meme starting to fall
-	var constantDuration = 400; // Constant duration for all fall animations regardless of distance
-	// Sort by column and row to make the animation more coherent
+	var baseDelay = 30;
+	var constantDuration = 400;
 	cellsToFall.sort(function (a, b) {
-		// Sort by column first
 		if (a.col !== b.col) {
 			return a.col - b.col;
 		}
-		// Then by destination row (lower row falls first) - this makes the animation go from bottom to top
 		return b.toRow - a.toRow;
 	});
-	// Apply animations with sequential delays
 	cellsToFall.forEach(function (fallInfo, index) {
-		var delay = index * baseDelay; // Each meme starts falling after the previous one
-		// Calculate destination position
+		var delay = index * baseDelay;
 		var newPos = getCellPosition(fallInfo.toRow, fallInfo.col);
-		// Track the longest delay + duration for later use
 		var totalTime = delay + constantDuration;
 		if (totalTime > longestDelay) {
 			longestDelay = totalTime;
 		}
-		// Schedule the animation with proper delay
 		LK.setTimeout(function () {
-			// Linear falling animation without bounce
+			//{1M} 
 			tween(fallInfo.cell, {
 				y: newPos.y
 			}, {
 				duration: constantDuration,
 				easing: tween.linear
 			});
 		}, delay);
 	});
-	// After all cells have fallen, fill in empty spaces at the top with new memes
-	// Use the actual total animation time rather than a fixed value
 	LK.setTimeout(function () {
-		window.gravityInProgress = false;
+		gravityInProgress = false;
 		fillEmptySpacesWithNewMemes();
-	}, longestDelay + 50); // Add a small buffer to ensure all falls are complete
+	}, longestDelay + 50);
 }
 // Create new memes to fill empty spots at the top of the grid
 function fillEmptySpacesWithNewMemes() {
-	// Check if we're already processing fill operation
-	if (window.fillInProgress) {
+	if (fillInProgress) {
 		return;
 	}
-	window.fillInProgress = true;
+	fillInProgress = true;
 	var anyNewMemeAdded = false;
-	// Collect all new cells to add for sequenced animation
 	var newCellsToAdd = [];
-	// Check each column for empty spaces
 	for (var col = 0; col < gridSize; col++) {
-		// Start from the top (row 0) and fill any empty spaces
 		for (var row = 0; row < gridSize + extraRows; row++) {
 			if (!gridCells[row][col]) {
 				anyNewMemeAdded = true;
-				// Create a new meme cell
 				var newCell = getGridCell();
 				var pos = getCellPosition(row, col);
-				// Position the new cell above the grid (for animation)
 				newCell.x = pos.x;
-				newCell.y = pos.y - 400; // Start above the visible grid
-				// Set random value for the new meme
+				newCell.y = pos.y - 400;
 				var randomValue = Math.floor(Math.random() * 5) + 1;
 				newCell.setValue(randomValue);
-				// Set logical position
 				newCell.row = row;
 				newCell.col = col;
-				// Add to grid array
 				gridCells[row][col] = newCell;
-				// Store cell data for animation
 				newCellsToAdd.push({
 					cell: newCell,
 					destY: pos.y,
 					row: row,
 					col: col
 				});
-				// Only add to display if in visible area
 				if (row >= extraRows) {
 					gridContainer.addChild(newCell);
 				}
 			}
 		}
 	}
-	// Animate cell drops with sequential delays
 	var longestDelay = 0;
-	var baseDelay = 30; // Delay between each meme starting to fall
-	var constantDuration = 400; // Constant duration for all fall animations regardless of distance
-	// Sort by column first, then by row for coherent animation - bottom to top
+	var baseDelay = 30;
+	var constantDuration = 400;
 	newCellsToAdd.sort(function (a, b) {
 		if (a.col !== b.col) {
 			return a.col - b.col;
 		}
-		return b.row - a.row; // Higher rows (lower in grid) fall first - bottom to top animation
+		return b.row - a.row;
 	});
-	// Apply animations with sequential delays
 	newCellsToAdd.forEach(function (cellData, index) {
 		var delay = index * baseDelay;
-		// Track total animation time
 		var totalTime = delay + constantDuration;
 		if (totalTime > longestDelay) {
 			longestDelay = totalTime;
 		}
-		// Schedule the animation with proper delay
 		LK.setTimeout(function () {
-			// Linear falling with no bounce
+			//{2l} 
 			tween(cellData.cell, {
 				y: cellData.destY
 			}, {
 				duration: constantDuration,
 				easing: tween.linear
 			});
 		}, delay);
 	});
-	// If new memes were added, check for matches only after all fall animations are complete
 	if (anyNewMemeAdded) {
 		LK.setTimeout(function () {
-			// Reset fill flag when animations are done
-			window.fillInProgress = false;
-			// Now that all falling animations are complete, check for matches
+			fillInProgress = false;
 			var newMatches = getMatches();
 			if (newMatches.length > 0) {
-				// Get all cells from all new match groups
 				var newCellsToDestroy = [];
 				var newCellTracker = {};
 				newMatches.forEach(function (group) {
 					group.forEach(function (cell) {
@@ -432,33 +348,26 @@
 							newCellTracker[cellKey] = true;
 						}
 					});
 				});
-				// Destroy these new matches only after all falling has fully completed
 				if (newCellsToDestroy.length) {
 					destroyCells(newCellsToDestroy);
 				}
 			} else {
-				// No more matches, animations are complete, allow user interaction again
 				isAnimating = false;
 			}
-		}, longestDelay + 50); // Use actual animation time plus buffer
+		}, longestDelay + 50);
 	} else {
-		// No new memes were added, animations are complete, allow user interaction again
-		window.fillInProgress = false;
+		fillInProgress = false;
 		isAnimating = false;
 	}
 }
 function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
-	// Get all potential matches on the board
 	var allMatchGroupsOnBoard = getMatches();
-	// Quick return if no matches
 	if (!allMatchGroupsOnBoard.length) {
-		return; // No matches found anywhere, nothing to do
+		return;
 	}
-	// Filter to only match groups containing one of the swapped cells
 	var relevantMatchGroups = allMatchGroupsOnBoard.filter(function (group) {
-		// Check if any cell in the group is one of our swapped cells
 		return group.some(function (cellInGroup) {
 			return cellInGroup === swappedCellA || cellInGroup === swappedCellB;
 		});
 	});