var Separator = Container.expand(function () {
	var self = Container.call(this);
	var separatorGraphics = self.createAsset('separator', 'Separator Graphics', 0.5, 0.5);
	separatorGraphics.alpha = 0;
	separatorGraphics.width = LK.getAsset('separator').width;
	separatorGraphics.height = LK.getAsset('separator').height * 4;
	self.collideWithDisc = function (disc) {
		var discGraphics = disc.getGraphics();
		var discEdgeX = disc.x + (disc.movingLeft ? -1 : 1) * discGraphics.width / 2;
		var discEdgeY = disc.y - discGraphics.height / 2;
		var separatorEdgeX = self.x + (disc.movingLeft ? 1 : -1) * separatorGraphics.width / 2;
		var separatorEdgeY = self.y - separatorGraphics.height / 2;
		var dx = discEdgeX - separatorEdgeX;
		var dy = discEdgeY - separatorEdgeY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < discGraphics.width / 2 + separatorGraphics.width / 2) {
			var normal = {
				x: (self.x - disc.x) / distance,
				y: (self.y - disc.y) / distance
			};
			var dotProduct = disc.velocity.x * normal.x + disc.velocity.y * normal.y;
			if (dotProduct > 0) {
				var mass1 = disc.mass;
				var mass2 = self.mass;
				var velocity1 = {
					x: disc.velocity.x,
					y: disc.velocity.y
				};
				var newVelocityX1 = velocity1.x;
				var newVelocityY1 = velocity1.y;
				disc.velocity.x = newVelocityX1 * disc.elasticity;
				disc.velocity.y = newVelocityY1 * disc.elasticity;
			}
		}
	};
});
var DiscIndicator = Container.expand(function () {
	var self = Container.call(this);
	var discGraphics = self.createAsset('disc', 'Disc Indicator Graphics', 0.5, 0.5);
	self.setCount = function (count) {
		self.removeChildren();
		for (var i = 0; i < count; i++) {
			var disc = self.createAsset('disc', 'Disc Indicator Graphics', 0.5, 0.5);
			disc.scale.set(0.5);
			disc.x = i * (discGraphics.width * 0.5) * 1.1;
			self.addChild(disc);
		}
	};
});
var Slot = Container.expand(function (pointValue) {
	var self = Container.call(this);
	self.slotGraphics;
	switch (pointValue) {
		case 10:
			self.slotGraphics = self.createAsset('slot_red', 'Slot Graphics', 0.5, 1);
			break;
		case 25:
			self.slotGraphics = self.createAsset('slot_blue', 'Slot Graphics', 0.5, 1);
			break;
		case 50:
			self.slotGraphics = self.createAsset('slot_green', 'Slot Graphics', 0.5, 1);
			break;
		case 100:
			self.slotGraphics = self.createAsset('slot_purple', 'Slot Graphics', 0.5, 1);
			break;
		default:
			self.slotGraphics = self.createAsset('slot', 'Slot Graphics', 0.5, 1);
			break;
	}
	self.pointValue = pointValue;
	var pointValueText = new Text2(self.pointValue.toString(), {
		size: 50,
		fill: '#ffffff'
	});
	pointValueText.anchor.set(0.5, 0);
	self.addChild(pointValueText);
	self.collideWithDisc = function (disc, updateScoreCallback) {
		disc.inSlot = true;
		disc.pointValue = self.pointValue;
		updateScoreCallback(disc.pointValue);
		if (self.pointValue === 100) {
			var remainingDiscs = self.parent && self.parent.discs ? self.parent.discs.length - self.parent.currentDiscIndex : 0;
			if (remainingDiscs < 3) {
				self.parent.createDisc.apply(self.parent);
			}
			self.parent.discIndicator.setCount(remainingDiscs + 1);
		}
	};
	self.setSize = function (width, height) {
		self.slotGraphics.width = width;
		self.slotGraphics.height = height;
		pointValueText.x = width / 2;
		pointValueText.y = height - pointValueText.height;
	};
});
var Peg = Container.expand(function () {
	var self = Container.call(this);
	var pegGraphics = self.createAsset('peg', 'Peg Graphics', .25, .25);
	self.collideWithDisc = function (disc) {
		var normal = {
			x: disc.x - self.x,
			y: disc.y - self.y
		};
		var length = Math.sqrt(normal.x * normal.x + normal.y * normal.y);
		normal.x /= length;
		normal.y /= length;
		var dotProduct = disc.velocity.x * normal.x + disc.velocity.y * normal.y;
		disc.velocity.x -= 5 * dotProduct * normal.x * disc.elasticity;
		disc.velocity.y -= 5 * dotProduct * normal.y * disc.elasticity;
	};
});
var Disc = Container.expand(function () {
	var self = Container.call(this);
	self.getGraphics = function () {
		return discGraphics;
	};
	var discGraphics = self.createAsset('disc', 'Disc Graphics', .25, .25);
	self.velocity = {
		x: 0,
		y: 0
	};
	self.elasticity = 0.2;
	self.gravity = 6;
	self.inSlot = false;
	self.pointValue = 0;
	self.x = LK.getAsset('disc').width / 2;
	self.y = LK.getAsset('disc').height / 2;
	self.velocity = {
		x: 0,
		y: 0
	};
	self.horizontalSpeed = 80;
	self.movingLeft = Math.random() < 0.5;
	self.move = function () {
		if (!self.inSlot) {
			var limit = 2048 * 0.2;
			if (self.movingLeft) {
				self.x -= self.horizontalSpeed;
				if (self.x <= limit) self.movingLeft = false;
			} else {
				self.x += self.horizontalSpeed;
				if (self.x >= 2048 - limit) self.movingLeft = true;
			}
			if (self.velocity.y !== 0 || self.velocity.x !== 0) {
				self.velocity.y += self.gravity * 0.5;
				self.x += self.velocity.x;
				self.y += self.velocity.y;
				if (self.x < 0 || self.x > 2048) {
					self.velocity.x *= -1;
				}
				if (self.y < 0 || self.y > 2732) {
					self.velocity.y *= -1;
				}
			}
		}
	};
	self.collideWithPeg = function (peg) {
		var dx = self.x - peg.x;
		var dy = self.y - peg.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < pegGraphics.width / 2 + discGraphics.width / 2) {
			var angle = Math.atan2(dy, dx);
			var sin = Math.sin(angle);
			var cos = Math.cos(angle);
			self.x = peg.x + (pegGraphics.width / 2 + discGraphics.width / 2) * cos;
			self.y = peg.y + (pegGraphics.width / 2 + discGraphics.width / 2) * sin;
			var dx1 = self.velocity.x;
			var dy1 = self.velocity.y;
			var speed = Math.sqrt(dx1 * dx1 + dy1 * dy1);
			var direction = Math.atan2(dy1, dx1);
			self.velocity.x = speed * Math.cos(direction + angle) * self.elasticity;
			self.velocity.y = speed * Math.sin(direction + angle) * self.elasticity;
			if (distance < pegGraphics.width / 2 + discGraphics.width / 2) {
				self.x = peg.x + (pegGraphics.width / 2 + discGraphics.width / 2) * cos;
				self.y = peg.y + (pegGraphics.width / 2 + discGraphics.width / 2) * sin;
			}
		}
	};
});
var Game = Container.expand(function () {
	var self = Container.call(this);
	self.createDisc = function () {
		var disc = new Disc();
		disc.alpha = 0;
		discs.push(disc);
		self.addChild(disc);
	};
	var background = self.createAsset('background', 'Background Graphics', 0, 0);
	background.width = 2048;
	background.height = 2732;
	background.alpha = 1;
	self.addChild(background);
	var separators = [];
	var totalSeparators = 6;
	var separatorSpacing = 2048 / (totalSeparators + 1);
	for (var i = 0; i < totalSeparators; i++) {
		var separator = new Separator();
		separator.x = separatorSpacing * (i + 1);
		separator.y = 2732 - separator.height / 2 - 40 + 50;
		separators.push(separator);
		self.addChild(separator);
	}
	stage.on('down', function (obj) {
		if (currentDiscIndex < discs.length) {
			var activeDisc = discs[currentDiscIndex];
			if (!activeDisc.inSlot) {
				activeDisc.velocity.y = 5;
				activeDisc.velocity.x = (Math.random() - 0.5) * 3;
				activeDisc.horizontalSpeed = 0;
				self.discIndicator.setCount(discs.length - currentDiscIndex - 1);
			}
		}
	});
	var scoreTxt = new Text2('0', {
		size: 100,
		fill: '#ffffff',
		stroke: '#000000',
		strokeThickness: 6,
		font: "'Luckiest Guy', 'Arial Black', sans-serif"
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.topCenter.addChild(scoreTxt);
	self.discIndicator = new DiscIndicator();
	self.discIndicator.x = 100;
	self.discIndicator.y = 70;
	LK.gui.addChild(self.discIndicator);
	self.discIndicator.setCount(5);
	function updateScore(pointValue) {
		totalScore += pointValue;
		scoreTxt.setText(totalScore.toString());
	}
	function updateUI() {
		scoreTxt.setText(totalScore.toString());
	}
	var pegs = [];
	var slots = [];
	var discs = [new Disc(), new Disc(), new Disc(), new Disc(), new Disc()];
	for (var i = 0; i < discs.length; i++) {
		discs[i].x = 2048 / 2;
		discs[i].y = 250;
		discs[i].velocity.x = 0;
		discs[i].velocity.y = 0;
		discs[i].visible = false;
		self.addChild(discs[i]);
	}
	discs[0].visible = true;
	var currentDiscIndex = 0;
	var totalScore = 0;
	function createDisc() {
		var disc = new Disc();
		discs.push(disc);
		self.addChild(disc);
	}
	var slotPoints = [10, 25, 50, 100, 50, 25, 10];
	var slotWidth = 2048 / slotPoints.length;
	for (var i = 0; i < slotPoints.length; i++) {
		var slot = new Slot(slotPoints[i]);
		slot.setSize(slotWidth, slotWidth);
		slot.x = i * slotWidth + 140;
		slot.y = 2732 - slot.slotGraphics.height + 500;
		slots.push(slot);
		slot.slotGraphics.alpha = 0;
		self.addChild(slot);
		var visualSlot = new Slot(slotPoints[i]);
		visualSlot.setSize(slotWidth, slotWidth);
		visualSlot.x = slot.x;
		visualSlot.y = slot.y - 200;
		self.addChild(visualSlot);
	}
	LK.on('tick', function () {
		if (currentDiscIndex < discs.length) {
			var activeDisc = discs[currentDiscIndex];
			if (!activeDisc.inSlot) {
				activeDisc.move();
				for (var i = 0; i < pegs.length; i++) {
					if (activeDisc.intersects(pegs[i])) {
						pegs[i].collideWithDisc(activeDisc);
					}
				}
				for (var i = 0; i < pegs.length; i++) {
					if (activeDisc.intersects(pegs[i])) {
						pegs[i].collideWithDisc(activeDisc);
					}
				}
				for (var s = 0; s < separators.length; s++) {
					for (var i = 0; i < activeDisc.velocity.y; i++) {
						if (activeDisc.intersects(separators[s])) {
							separators[s].collideWithDisc(activeDisc, activeDisc.discGraphics);
						}
					}
				}
				for (var j = 0; j < slots.length; j++) {
					if (activeDisc.intersects(slots[j]) && !activeDisc.inSlot) {
						slots[j].collideWithDisc(activeDisc, updateScore);
						activeDisc.inSlot = true;
						currentDiscIndex++;
						self.discIndicator.setCount(discs.length - currentDiscIndex);
						if (currentDiscIndex < discs.length) {
							if (discs[currentDiscIndex - 1].inSlot) {
								discs[currentDiscIndex].x = Math.random() * 2048;
								discs[currentDiscIndex].y = 250;
								discs[currentDiscIndex].velocity.x = 0;
								discs[currentDiscIndex].velocity.y = 0;
								discs[currentDiscIndex].horizontalSpeed = 80;
								discs[currentDiscIndex].movingLeft = Math.random() < 0.5;
								discs[currentDiscIndex].visible = true;
								discs[currentDiscIndex].alpha = 1;
							}
						}
					}
				}
			}
			if (currentDiscIndex == discs.length) {
				var allDiscsInSlots = discs.every(function (disc) {
					return disc.inSlot;
				});
				var lastDisc = discs[discs.length - 1];
				if (allDiscsInSlots && (!lastDisc.inSlot || lastDisc.pointValue !== 100)) {
					LK.showGameOver();
					totalScore = 0;
					currentDiscIndex = 0;
					discs.forEach(function (disc) {
						disc.x = 2048 / 2;
						disc.y = 850;
						disc.velocity.y = 0;
						disc.velocity.x = 0;
						disc.inSlot = false;
					});
				}
			}
		}
	});
	var pegOffsetX = 2048 / 7;
	var pegOffsetY = (2732 - pegOffsetX) / 9;
	var marginX = pegOffsetX / 2 - 20;
	for (var row = 0; row < 8; row++) {
		var numberOfPegsInRow = row % 2 === 0 ? 7 : 6;
		for (var col = 0; col < numberOfPegsInRow; col++) {
			var peg = new Peg();
			var staggerOffset = row % 2 * (pegOffsetX / 2);
			peg.x = marginX + col * pegOffsetX + staggerOffset;
			peg.y = pegOffsetY + row * pegOffsetY + 190;
			pegs.push(peg);
			self.addChild(peg);
		}
	}
});

===================================================================
--- original.js
+++ change.js
@@ -128,18 +128,19 @@
 	self.velocity = {
 		x: 0,
 		y: 0
 	};
-	self.horizontalSpeed = 64;
+	self.horizontalSpeed = 80;
 	self.movingLeft = Math.random() < 0.5;
 	self.move = function () {
 		if (!self.inSlot) {
+			var limit = 2048 * 0.2;
 			if (self.movingLeft) {
 				self.x -= self.horizontalSpeed;
-				if (self.x <= 0) self.movingLeft = false;
+				if (self.x <= limit) self.movingLeft = false;
 			} else {
 				self.x += self.horizontalSpeed;
-				if (self.x >= 2048) self.movingLeft = true;
+				if (self.x >= 2048 - limit) self.movingLeft = true;
 			}
 			if (self.velocity.y !== 0 || self.velocity.x !== 0) {
 				self.velocity.y += self.gravity * 0.5;
 				self.x += self.velocity.x;