/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	score: 0,
	tapValue: 1,
	upgradeLevel: 1,
	upgradeCost: 10,
	hasAutoClicker: false,
	autoClickerLevel: 1,
	rebirthLevel: 0,
	rebirthMultiplier: 1
});

/**** 
* Classes
****/ 
var AutoClickerButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphic = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.text = new Text2('Auto Click: 1000', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	// Properties
	self.active = false;
	self.timer = null;
	self.clickInterval = 1000; // Default 1 second
	self.level = 1;
	self.updateText = function (cost) {
		if (self.level >= 19) {
			self.text.setText('Auto Click: MAX');
		} else {
			self.text.setText('Auto Click: ' + cost);
		}
	};
	self.down = function () {
		tween(buttonGraphic, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			easing: tween.easeOut
		});
	};
	self.up = function () {
		tween(buttonGraphic, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 100,
			easing: tween.easeOut
		});
		if (!hasAutoClicker) {
			attemptBuyAutoClicker();
		} else if (self.level < 9) {
			attemptUpgradeAutoClicker();
		}
	};
	self.activate = function () {
		self.active = true;
		self.restartTimer();
	};
	self.restartTimer = function () {
		if (self.timer) {
			LK.clearInterval(self.timer);
		}
		self.timer = LK.setInterval(function () {
			if (tapValue > 0) {
				// Auto click adds points based on tap value
				score += tapValue;
				storage.score = score;
				updateScoreDisplay();
			}
		}, self.clickInterval);
	};
	self.upgrade = function () {
		self.level++;
		// Update click interval based on level
		switch (self.level) {
			case 2:
				self.clickInterval = 900; // 0.000000000000000000000001 seconds
				break;
			case 3:
				self.clickInterval = 800; // 0.000000000000000000000000000000008 seconds
				break;
			case 4:
				self.clickInterval = 700; // 0.0000000000000000000000000000000000000006 seconds
				break;
			case 5:
				self.clickInterval = 500; // 0.00000000000000000000000000000000000000000000000000000000000002 seconds
				break;
			case 6:
				self.clickInterval = 10; // 0.01 seconds
				break;
			case 7:
				self.clickInterval = 300; // 0.001 seconds
				break;
			case 8:
				self.clickInterval = 200; // 0.000000000ü000000000000000000001 seconds
				break;
			case 9:
				self.clickInterval = 100; // 0.00000000000000000000000001 seconds
				break;
			case 10:
				self.clickInterval = 90; // 0.0000000000000009 seconds
				break;
			case 11:
				self.clickInterval = 80; // 0.0000000000006 seconds
				break;
			case 12:
				self.clickInterval = 70; // 0.0000000007
				seconds;
				break;
			case 13:
				self.clickInterval = 60; // 0.00000000006 seconds
				break;
			case 14:
				self.clickInterval = 50; // 0.000000000000000000000000000000000000000005 seconds
				break;
			case 15:
				self.clickInterval = 50; // 0.0000000000000000000004 seconds
				break;
			case 16:
				self.clickInterval = 40; // 0.04 seconds
				break;
			case 17:
				self.clickInterval = 30; // 0.03 seconds
				break;
			case 18:
				self.clickInterval = 20; // 0.02 seconds
				break;
			case 19:
				self.clickInterval = 10; // 0.01 seconds
				break;
		}
		// Update cost display
		if (self.level < 19) {
			self.updateText(getAutoClickerUpgradeCost());
		} else {
			self.updateText("MAX");
		}
		// Restart timer with new interval
		if (self.active) {
			self.restartTimer();
		}
	};
	self.disable = function () {
		buttonGraphic.alpha = 0.5;
	};
	self.enable = function () {
		buttonGraphic.alpha = 1;
	};
	return self;
});
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphic = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Pulse animation when active
	self.pulse = function () {
		// Stop any existing animation
		tween.stop(coinGraphic, {
			scaleX: true,
			scaleY: true
		});
		// Scale up
		tween(coinGraphic, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Scale back down
				tween(coinGraphic, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.elasticOut
				});
			}
		});
	};
	return self;
});
var RebirthButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphic = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x9c27b0 // Purple color for rebirth button
	});
	self.text = new Text2('REBIRTH: 10K', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	self.updateText = function (rebirthCost) {
		self.text.setText('REBIRTH: ' + formatScore(rebirthCost));
	};
	self.down = function () {
		tween(buttonGraphic, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			easing: tween.easeOut
		});
	};
	self.up = function () {
		tween(buttonGraphic, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 100,
			easing: tween.easeOut
		});
		// Only perform rebirth if player can afford it
		var rebirthCost = getRebirthCost();
		if (score === Infinity || score >= rebirthCost) {
			performRebirth();
		}
	};
	self.disable = function () {
		buttonGraphic.alpha = 0.5;
	};
	self.enable = function () {
		buttonGraphic.alpha = 1;
	};
	return self;
});
var ShockWave = Container.expand(function () {
	var self = Container.call(this);
	// Create the shock wave circle
	var waveGraphic = self.attachAsset('tapEffect', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.7
	});
	// Animation method for the shock wave
	self.animate = function (x, y) {
		// Set position
		self.x = x;
		self.y = y;
		// Start with small scale and high opacity
		waveGraphic.scaleX = 0.1;
		waveGraphic.scaleY = 0.1;
		waveGraphic.alpha = 0.8;
		// First expand the wave quickly
		tween(waveGraphic, {
			scaleX: 3,
			scaleY: 3,
			alpha: 0.6
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Then continue expanding and fade out
				tween(waveGraphic, {
					scaleX: 8,
					scaleY: 8,
					alpha: 0
				}, {
					duration: 500,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Remove when done
						if (self.parent) {
							self.parent.removeChild(self);
						}
					}
				});
			}
		});
	};
	return self;
});
var TapEffect = Container.expand(function () {
	var self = Container.call(this);
	var effectGraphic = self.attachAsset('tapEffect', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.7
	});
	self.animate = function (x, y, pointsEarned) {
		self.x = x;
		self.y = y;
		self.alpha = 1;
		effectGraphic.scaleX = 0.5;
		effectGraphic.scaleY = 0.5;
		// Create points text
		var pointsText = new Text2("+" + pointsEarned, {
			size: 60,
			fill: 0xFFFFFF
		});
		pointsText.anchor.set(0.5, 0.5);
		self.addChild(pointsText);
		// Animate effect
		tween(effectGraphic, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 500,
			easing: tween.easeOut
		});
		// Animate text floating up
		tween(pointsText, {
			y: -100,
			alpha: 0
		}, {
			duration: 800,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.removeChild(pointsText);
				pointsText = null;
			}
		});
	};
	return self;
});
var UpgradeButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphic = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.text = new Text2('Upgrade: 10 points', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	self.updateText = function (cost) {
		self.text.setText('Upgrade: ' + cost + ' points');
	};
	self.down = function () {
		tween(buttonGraphic, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			easing: tween.easeOut
		});
	};
	self.up = function () {
		tween(buttonGraphic, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 100,
			easing: tween.easeOut
		});
		attemptUpgrade();
	};
	self.disable = function () {
		buttonGraphic.alpha = 0.5;
	};
	self.enable = function () {
		buttonGraphic.alpha = 1;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Reset game variables to initial state
var score = Infinity;
var tapValue = 10000; // 1 points per tap
var upgradeLevel = 1;
var upgradeCost = 10;
var autoClickerLevel = 1;
var autoClickerCost = 1000;
var hasAutoClicker = false;
var rebirthLevel = 0;
var rebirthMultiplier = 1;
// Save reset values to storage
storage.score = Infinity;
storage.tapValue = 10000; // 1 points per tap
storage.upgradeLevel = 1;
storage.upgradeCost = 10;
storage.autoClickerLevel = 1;
storage.hasAutoClicker = false;
storage.rebirthLevel = 0;
storage.rebirthMultiplier = 1;
var effects = [];
// Function to get auto clicker upgrade cost based on level
function getAutoClickerUpgradeCost() {
	if (autoClickerLevel === 1) {
		return 1000; // Base price for first level
	} else if (autoClickerLevel < 19) {
		// Get previous level cost and multiply by 1.5
		var baseCost = 1000; // Level 1 cost
		for (var i = 1; i < autoClickerLevel; i++) {
			baseCost = Math.floor(baseCost * 1.5);
		}
		return baseCost;
	} else {
		return Infinity; // No more upgrades
	}
}
// Create upgrade button in top left (but not too close to the corner)
var upgradeButton = new UpgradeButton();
upgradeButton.x = 400;
upgradeButton.y = 150;
upgradeButton.updateText(upgradeCost);
game.addChild(upgradeButton);
// Create auto clicker button below the upgrade button
var autoClickerButton = new AutoClickerButton();
autoClickerButton.x = 400;
autoClickerButton.y = 320;
autoClickerButton.updateText(1000);
autoClickerButton.visible = false; // Hide by default, visibility will be controlled by updateAutoClickerVisibility()
game.addChild(autoClickerButton);
// Auto clicker button position is maintained at y=320
// Don't activate auto clicker by default as game is reset
if (hasAutoClicker) {
	// Set the correct level and interval for purchased auto clicker
	autoClickerButton.level = autoClickerLevel;
	// Set default interval
	autoClickerButton.clickInterval = 1000; // 1 second (default speed)
	// Update click interval based on level
	switch (autoClickerLevel) {
		case 2:
			autoClickerButton.clickInterval = 900; // 0.9 seconds
			break;
		case 3:
			autoClickerButton.clickInterval = 800; // 0.8 seconds
			break;
		case 4:
			autoClickerButton.clickInterval = 700; // 0.7 seconds
			break;
		case 5:
			autoClickerButton.clickInterval = 500; // 0.5 seconds
			break;
		case 6:
			autoClickerButton.clickInterval = 10; // 0.01 seconds
			break;
		case 7:
			autoClickerButton.clickInterval = 300; // 0.3 seconds
			break;
		case 8:
			autoClickerButton.clickInterval = 200; // 0.2 seconds
			break;
		case 9:
			autoClickerButton.clickInterval = 100; // 0.1 seconds
			break;
		case 10:
			autoClickerButton.clickInterval = 90; // 0.09 seconds
			break;
		case 11:
			autoClickerButton.clickInterval = 80; // 0.08 seconds
			break;
		case 12:
			autoClickerButton.clickInterval = 70; // 0.07 seconds
			break;
		case 13:
			autoClickerButton.clickInterval = 60; // 0.06 seconds
			break;
		case 14:
			autoClickerButton.clickInterval = 50; // 0.05 seconds
			break;
		case 15:
			autoClickerButton.clickInterval = 50; // 0.05 seconds
			break;
		case 16:
			autoClickerButton.clickInterval = 40; // 0.04 seconds
			break;
		case 17:
			autoClickerButton.clickInterval = 30; // 0.03 seconds
			break;
		case 18:
			autoClickerButton.clickInterval = 20; // 0.02 seconds
			break;
		case 19:
			autoClickerButton.clickInterval = 10; // 0.01 seconds
			break;
	}
	autoClickerButton.activate();
}
// Function to check if auto clicker should be visible
function updateAutoClickerVisibility() {
	if (score === Infinity || score >= autoClickerCost || hasAutoClicker) {
		autoClickerButton.visible = true;
	} else {
		autoClickerButton.visible = false;
	}
}
// Create score display
var scoreText = new Text2('Points: 0', {
	size: 100,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Create tap value display
var tapValueText = new Text2('Points per tap: ' + tapValue, {
	size: 60,
	fill: 0xFFFFFF
});
tapValueText.anchor.set(0.5, 0);
tapValueText.y = 120;
LK.gui.top.addChild(tapValueText);
// Create rebirth level display
var rebirthText = new Text2('Rebirth Level: 0 (x1)', {
	size: 50,
	fill: 0x9c27b0
});
rebirthText.anchor.set(0.5, 0);
rebirthText.y = 190;
LK.gui.top.addChild(rebirthText);
// Format large numbers with K, M, B, T suffixes
function formatScore(num) {
	if (num === Infinity) {
		return "∞";
	} else if (num >= 1000000000000000) {
		// Quadrillion
		var q = num / 1000000000000000;
		return (Math.floor(q * 10) / 10).toFixed(1).replace(/\.0$/, '') + 'Q';
	} else if (num >= 1000000000000) {
		// Trillion
		var t = num / 1000000000000;
		return (Math.floor(t * 10) / 10).toFixed(1).replace(/\.0$/, '') + 'T';
	} else if (num >= 1000000000) {
		// Billion
		var b = num / 1000000000;
		return (Math.floor(b * 10) / 10).toFixed(1).replace(/\.0$/, '') + 'B';
	} else if (num >= 1000000) {
		// Million
		var m = num / 1000000;
		return (Math.floor(m * 10) / 10).toFixed(1).replace(/\.0$/, '') + 'M';
	} else if (num >= 1000) {
		// Thousand
		var k = num / 1000;
		return (Math.floor(k * 10) / 10).toFixed(1).replace(/\.0$/, '') + 'K';
	} else {
		return num.toString();
	}
}
// Update score display
function updateScoreDisplay() {
	scoreText.setText('Points: ' + formatScore(score));
	tapValueText.setText('Points per tap: ' + tapValue);
	rebirthText.setText('Rebirth Level: ' + rebirthLevel + ' (x' + rebirthMultiplier + ')');
	// Check if player can afford upgrade
	if (score === Infinity || score >= upgradeCost) {
		upgradeButton.enable();
	} else {
		upgradeButton.disable();
	}
	// Check if auto clicker should be visible
	updateAutoClickerVisibility();
	// Restart auto clicker if tap value changed from 0
	if (tapValue > 0 && autoClickerButton.active && !autoClickerButton.timer) {
		autoClickerButton.restartTimer();
	}
	// Disable auto clicker functionality if tap value is 0
	if (tapValue === 0 && autoClickerButton.active) {
		if (autoClickerButton.timer) {
			LK.clearInterval(autoClickerButton.timer);
			autoClickerButton.timer = null;
		}
	}
	// Enable/disable auto clicker button based on score
	if (!hasAutoClicker) {
		if (score === Infinity || score >= autoClickerCost) {
			autoClickerButton.enable();
		} else {
			autoClickerButton.disable();
		}
	} else if (autoClickerLevel < 19) {
		// If has auto clicker but not max level, check if can afford upgrade
		var nextUpgradeCost = getAutoClickerUpgradeCost();
		if (score === Infinity || score >= nextUpgradeCost) {
			autoClickerButton.enable();
		} else {
			autoClickerButton.disable();
		}
	}
	// Enable/disable rebirth button based on score
	var rebirthCost = getRebirthCost();
	if (score === Infinity || score >= rebirthCost) {
		rebirthButton.enable();
		rebirthButton.updateText(rebirthCost);
	} else {
		rebirthButton.disable();
		rebirthButton.updateText(rebirthCost);
	}
}
// Attempt to purchase an upgrade
function attemptUpgrade() {
	if (score === Infinity || score >= upgradeCost) {
		// Deduct points if not infinite
		if (score !== Infinity) {
			score -= upgradeCost;
		}
		// Increase tap value
		upgradeLevel++;
		tapValue = upgradeLevel;
		// Calculate new upgrade cost (increase by 10%)
		upgradeCost = Math.floor(upgradeCost * 1.1);
		// Update button text
		upgradeButton.updateText(upgradeCost);
		// Save progress
		storage.score = score;
		storage.tapValue = tapValue;
		storage.upgradeLevel = upgradeLevel;
		storage.upgradeCost = upgradeCost;
		// Update display
		updateScoreDisplay();
		// Play upgrade sound
		LK.getSound('upgrade').play();
	}
}
// Attempt to purchase auto clicker
function attemptBuyAutoClicker() {
	if (!hasAutoClicker && (score === Infinity || score >= autoClickerCost)) {
		// Deduct points if not infinite
		if (score !== Infinity) {
			score -= autoClickerCost;
		}
		// Activate auto clicker
		hasAutoClicker = true;
		storage.hasAutoClicker = true;
		storage.autoClickerLevel = 1;
		storage.score = score;
		// Update display
		updateScoreDisplay();
		// Activate auto clicker functionality
		autoClickerButton.activate();
		// Play upgrade sound
		LK.getSound('upgrade').play();
	}
}
// Removed resetAutoClicker function
// Attempt to upgrade auto clicker
function attemptUpgradeAutoClicker() {
	// Don't proceed if already at max level
	if (autoClickerLevel >= 19) {
		return;
	}
	// Get the cost for the current level upgrade
	var upgradeCost = getAutoClickerUpgradeCost();
	// Check if player can afford the upgrade
	if (score === Infinity || score >= upgradeCost) {
		// Deduct points if not infinite
		if (score !== Infinity) {
			score -= upgradeCost;
		}
		// Upgrade auto clicker
		autoClickerLevel++;
		// Save progress
		storage.score = score;
		storage.autoClickerLevel = autoClickerLevel;
		// Update auto clicker button
		autoClickerButton.upgrade();
		// Update display
		updateScoreDisplay();
		// Play upgrade sound
		LK.getSound('upgrade').play();
	}
}
// Create tap effect
function createTapEffect(x, y) {
	var effect = new TapEffect();
	game.addChild(effect);
	effect.animate(x, y, tapValue);
	// Remove effect after animation
	LK.setTimeout(function () {
		if (effect.parent) {
			game.removeChild(effect);
		}
	}, 1000);
}
// Handle tapping on the game
game.down = function (x, y) {
	// Check if tap value is greater than 0
	if (tapValue > 0) {
		// Add points
		score += tapValue;
		// Save progress
		storage.score = score;
		// Create visual effect for points
		createTapEffect(x, y);
	}
	// Update display
	updateScoreDisplay();
	// Create shock wave effect
	var shockWave = new ShockWave();
	game.addChild(shockWave);
	shockWave.animate(x, y);
	// Play tap sound
	LK.getSound('tap').play();
};
// Function to get rebirth cost based on level
function getRebirthCost() {
	if (rebirthLevel === 0) {
		return 10000; // Base cost: 10K
	} else if (rebirthLevel < 6) {
		return 10000; // Same cost for first several levels: 10K
	} else if (rebirthLevel < 10) {
		return 1000000; // 1M for higher levels
	} else if (rebirthLevel < 15) {
		return 1000000000; // 1B for even higher levels
	} else {
		return 1000000000000; // 1T for highest levels
	}
}
// Create rebirth button in bottom right
var rebirthButton = new RebirthButton();
rebirthButton.x = 1800;
rebirthButton.y = 2500;
rebirthButton.updateText(getRebirthCost());
game.addChild(rebirthButton);
// Rebirth multiplier and level
var rebirthMultiplier = 1;
var rebirthLevel = 0;
// Function to perform rebirth
function performRebirth() {
	// Get current rebirth cost based on level
	var rebirthCost = getRebirthCost();
	// Check if player can afford rebirth
	if (score === Infinity || score >= rebirthCost) {
		// Deduct points if not infinite
		if (score !== Infinity) {
			score -= rebirthCost;
		}
		// Increase rebirth level and multiplier
		rebirthLevel++;
		rebirthMultiplier = Math.pow(2, rebirthLevel); // Double multiplier per rebirth level (2^level)
		// Reset game variables but keep rebirth multiplier and infinity status
		if (score === Infinity) {
			// If score is infinity, keep it infinity
			score = Infinity;
		} else {
			// Otherwise reset to zero
			score = 0;
		}
		upgradeLevel = 1;
		tapValue = upgradeLevel * rebirthMultiplier;
		upgradeCost = 10;
		// Keep auto clicker if purchased but reset its level
		if (hasAutoClicker) {
			autoClickerLevel = 1;
			autoClickerButton.level = 1;
			autoClickerButton.clickInterval = 1000;
			// Reset auto clicker display
			autoClickerButton.updateText(getAutoClickerUpgradeCost());
			// Restart auto clicker
			autoClickerButton.restartTimer();
		}
		// Update storage values
		storage.score = score;
		storage.tapValue = tapValue;
		storage.upgradeLevel = upgradeLevel;
		storage.upgradeCost = upgradeCost;
		storage.autoClickerLevel = autoClickerLevel;
		storage.rebirthLevel = rebirthLevel;
		storage.rebirthMultiplier = rebirthMultiplier;
		// Update displays
		upgradeButton.updateText(upgradeCost);
		updateScoreDisplay();
		rebirthButton.updateText(getRebirthCost());
		// Flash screen effect for rebirth
		LK.effects.flashScreen(0x9c27b0, 500);
		// Play upgrade sound for rebirth
		LK.getSound('upgrade').play();
	}
}
// Load values from storage
if (storage.score !== undefined) {
	score = storage.score;
}
if (storage.tapValue !== undefined) {
	tapValue = storage.tapValue;
}
if (storage.upgradeLevel !== undefined) {
	upgradeLevel = storage.upgradeLevel;
}
if (storage.upgradeCost !== undefined) {
	upgradeCost = storage.upgradeCost;
}
if (storage.hasAutoClicker !== undefined) {
	hasAutoClicker = storage.hasAutoClicker;
}
if (storage.autoClickerLevel !== undefined) {
	autoClickerLevel = storage.autoClickerLevel;
}
// Load rebirth values from storage
if (storage.rebirthLevel !== undefined) {
	rebirthLevel = storage.rebirthLevel;
}
if (storage.rebirthMultiplier !== undefined) {
	rebirthMultiplier = storage.rebirthMultiplier;
} else {
	rebirthMultiplier = Math.pow(2, rebirthLevel);
}
// Initial setup
updateScoreDisplay();
updateAutoClickerVisibility();
// Play background music
LK.playMusic('bgmusic', {
	fade: {
		start: 0,
		end: 0.3,
		duration: 1000
	}
});

===================================================================
--- original.js
+++ change.js
@@ -745,9 +745,9 @@
 			score -= rebirthCost;
 		}
 		// Increase rebirth level and multiplier
 		rebirthLevel++;
-		rebirthMultiplier = rebirthLevel + 1; // Simple +1 multiplier per rebirth level
+		rebirthMultiplier = Math.pow(2, rebirthLevel); // Double multiplier per rebirth level (2^level)
 		// Reset game variables but keep rebirth multiplier and infinity status
 		if (score === Infinity) {
 			// If score is infinity, keep it infinity
 			score = Infinity;
@@ -755,9 +755,9 @@
 			// Otherwise reset to zero
 			score = 0;
 		}
 		upgradeLevel = 1;
-		tapValue = 2 * rebirthMultiplier;
+		tapValue = upgradeLevel * rebirthMultiplier;
 		upgradeCost = 10;
 		// Keep auto clicker if purchased but reset its level
 		if (hasAutoClicker) {
 			autoClickerLevel = 1;