swfchan: Amber's Pinball Journey (Incomplete) by Doom-the-wolf.swf (info)

Text
GRADIENT
HERE
Interactive pregnant Reshiram (Incomplete)
Draw, animated and programmed by Doom the wolf
http://doom-the-wolf.deviantart.com
It's
PARTY
TIME!
Amber's Pinball Journey
(Incomplete progress)
1. Destroy the
apple targets.
2. Apple bumper
disappears.
Bring the ball to
the Helium tank
behind it.
3. Collect points with
the ball.
(Not implemented yet)
If you lose the ball,
you lose the points.
4. INFLATE indicator
lights up when you
collect enough points.
5. Put the ball in.
Inflate Amber!
Growth depends
on the points
collected by the
ball.
(Inflation not
implemented yet)
Points
accumulated by
the ball get saved.
CLICK ANYWHERE TO BEGIN
ActionScript [AS3]
Section 1
//belly_60 (game_fla.belly_60)
package game_fla {
	import flash.display.*;

	public dynamic class belly_60 extends MovieClip {

		public var fur1:MovieClip;
		public var fur3:MovieClip;
		public var fur2:MovieClip;

	}
}//package game_fla 
Section 2
//head_55 (game_fla.head_55)
package game_fla {
	import flash.display.*;

	public dynamic class head_55 extends MovieClip {

		public var eye:MovieClip;
		public var mouth:MovieClip;

	}
}//package game_fla 
Section 3
//MainTimeline (game_fla.MainTimeline)
package game_fla {
	import flash.events.*;
	import flash.display.*;
	import flash.ui.*;
	import pinball.*;
	import flash.utils.*;
	import flash.text.*;
	import adobe.utils.*;
	import flash.accessibility.*;
	import flash.errors.*;
	import flash.external.*;
	import flash.filters.*;
	import flash.geom.*;
	import flash.media.*;
	import flash.net.*;
	import flash.printing.*;
	import flash.system.*;
	import flash.xml.*;

	public dynamic class MainTimeline extends MovieClip {

		public const SAVE_BALL_ANIM:int = 3;
		public const MIN_INFLATION_POINTS:int = 0;
		public const NUM_FLIPPER_FRAMES:int = 2;
		public const TARGETB_COUNTER:int = 3;
		public const SIDE_PANEL_XSCALE:Number = 0;
		public const BITMAP_CACHING:Boolean = true;
		public const SHOOTER_MULT:Number = 2;
		public const EXTRA_BALL_APPLES:int = 10;
		public const BOUNCY_MULT:Number = 1.2;
		public const STAGE_WIDTH:int = 800;
		public const TABLE_TOP:int;
		public const ANIM_BG_COLOR:int = 39423;
		public const KEYBOARD_LEFT:String = "QWERTASDFGZXCV";
		public const ANIMATION_FPS:int = 20;
		public const WARP_ANIM:int = 1;
		public const INFLATE_ANIM:int = 2;
		public const STAGE_HEIGHT:int = 600;
		public const TABLE_WIDTH1_2:int = 400;
		public const ANIM_BG_HEIGHT:int = 200;
		public const NO_ANIM:int = 0;
		public const TABLE_WIDTH:int = 800;
		public const AS_START:int = 0;
		public const ANIM_H_SPACE:int = 170;
		public const LAUNCHER_ID:int = -1;
		public const ANIM_BG_SPEED:int = 29;
		public const WALL_MULT:Number = 0.4;
		public const ANIM_H_RADIUS:int = 60;
		public const TABLE_HEIGHT:int = 600;
		public const ANIM_H_OFFSET:int = -65;
		public const GAME_FPS:int = 50;
		public const ANIM_V_RADIUS:int = 3;
		public const ANIM_V_OFFSET:int = 0;
		public const AS_PLAY:int = 1;
		public const AS_END:int = 2;
		public const BOUNCY_COUNTER:int = 3;
		public const TABLE_TOP_XSCALE:Number = 0.916666666666667;
		public const SHAKE_RIGHT_ID:int = -3;
		public const BUMPER_MULT:Number = 1.2;
		public const ANIM_COLOR:int = 13430527;
		public const ANIM_V_SPACE:int = 20;
		public const KEYBOARD_RIGHT:String = "YUIOPHJKLBNM";
		public const TABLE_BACK_YSCALE:Number = 0;
		public const SHAKE_LEFT_ID:int = -2;

		public var entranceWallWidth:Number;
		public var bouncyThird:Number;
		public var warpWidth:Number;
		public var smallEndX2:Number;
		public var leftAreaSpace:Number;
		public var FLIPPER_BASE:Number;
		public var minF:int;
		public var smallEndX1:Number;
		public var leftGemProp1:Number;
		public var leftGemProp2:Number;
		public var smallEndY1:Number;
		public var smallEndY2:Number;
		public var topLightState:int;
		public var launchSpeed:Number;
		public var gemCenterY:Number;
		public var starY:Number;
		public var cMenu:ContextMenu;
		public var gemCenterX:Number;
		public var starX:Number;
		public var i:int;
		public var externalBall:MovieClip;
		public var t:int;
		public var bouncyWidth:Number;
		public var leftAreaThird:Number;
		public var launchDetector:Object;
		public var FLIPPER_SPEED:Number;
		public var flipper1:int;
		public var FLIPPER_LENGTH:Number;
		public var flipper2:int;
		public var entranceWidth:Number;
		public var panelTop:MovieClip;
		public var bumperRad:Number;
		public var amberTable:Table;
		public var gemDepth:Number;
		public var sideHoles:Array;
		public var targetsAY:Number;
		public var keysDown:Array;
		public var previousHitState:Dictionary;
		public var cornerWallX1:Number;
		public var goldApples:int;
		public var rampWidth:Number;
		public var cornerWallX2:Number;
		public var goldBumper:Object;
		public var holeWidth:Number;
		public var animationBmp2:Bitmap;
		public var cornerWallY2:Number;
		public var leftAreaWidth:Number;
		public var cornerWallY1:Number;
		public var bouncySwitch:Object;
		public var animationBmp1:Bitmap;
		public var lightState:int;
		public var bell:Object;
		public var FLIPPER_ANGLE:Number;
		public var centerBumperTop:Number;
		public var animationClip:MovieClip;
		public var bgClip:MovieClip;
		public var balloonBumpers:Array;
		public var flipper1Frame:int;
		public var currentHitState:Dictionary;
		public var animationContainer:MovieClip;
		public var centerBumperBottom:Number;
		public var warpEntrance:Object;
		public var MAX_FLIPPER_ANGLE:Number;
		public var sideHeight:Number;
		public var topWidth:Number;
		public var curItem:Object;
		public var remainingWidth:Number;
		public var FLIPPER_END:Number;
		public var gemHeight:Number;
		public var starRadius:Number;
		public var caveLight:Object;
		public var tempTargetBW:Number;
		public var gemHeight2:Number;
		public var oldTime:int;
		public var centerSpace:Number;
		public var tempTargetBY:Number;
		public var bouncyHeight2:Number;
		public var lightsB:Array;
		public var pathTrigger:Object;
		public var lightsA:Array;
		public var FLIPPER1_FRAMES:Array;
		public var flipper2Frame:int;
		public var flipper1_mc:MovieClip;
		public var ball:Object;
		public var triangleCornerHeight:Number;
		public var holeHeight:Number;
		public var drain:Object;
		public var oldMX:Number;
		public var animationBGData:BitmapData;
		public var wallWidth:Number;
		public var fList:Array;
		public var animationTimer:int;
		public var centerThird:Number;
		public var smallThickness:Number;
		public var centerTargetPos:Number;
		public var rightKeys:int;
		public var entranceTrigger2:Object;
		public var flipper2_mc:MovieClip;
		public var entranceTrigger1:Object;
		public var tablePoints:int;
		public var centerBumpers:Array;
		public var entranceTrigger3:Object;
		public var bottomWidth:Number;
		public var pauseClip:TextField;
		public var txt:TextField;
		public var ALPHABET:String;
		public var tableOffsetX:Number;
		public var tableOffsetY:Number;
		public var panelRight:MovieClip;
		public var centerWidth:Number;
		public var keyMap:Array;
		public var BALL_STARTX:Number;
		public var BALL_STARTY:Number;
		public var leftKeys:int;
		public var sideWidth:Number;
		public var cornerWallProp2:Number;
		public var inflationPoints:int;
		public var cornerWallProp1:Number;
		public var lightsBRadius:Number;
		public var remainingHeight:Number;
		public var FLIPPER2_FRAMES:Array;
		public var animFrameFunc:Function;
		public var tableDestY:Number;
		public var gemEndX:Number;
		public var invGemTangent:Number;
		public var tableDestX:Number;
		public var reshiram:MovieClip;
		public var animationBG:MovieClip;
		public var board:tableBack;
		public var bouncyHeight:Number;
		public var BALL_RADIUS:int;
		public var animEndFunc:Function;
		public var animParams:Object;
		public var gemMidX:Number;
		public var centerTargetHeight:Number;
		public var HEX_VALUES:Array;
		public var dragonAmberTable:Table;
		public var gemProp2:Number;
		public var gemProp1:Number;
		public var centerTargetWidth:Number;
		public var animStartFunc:Function;
		public var halfHeight:Number;
		public var inflateLight:Object;
		public var caveEntranceX:Number;
		public var caveEntranceY:Number;
		public var maxF:int;
		public var triangles:Array;
		public var animationState:int;
		public var lightsARadius:Number;
		public var triangleFrontY:Number;
		public var prop:Number;
		public var entranceHeight:Number;
		public var targetsA:Array;
		public var targetsB:Array;
		public var oldFrame:int;
		public var entranceDoor:Object;
		public var upperTargetState:int;
		public var wallHeight:Number;
		public var bigBumperRad:Number;
		public var cave:Object;
		public var triangleFrontX:Number;
		public var animationID:int;
		public var launcher:Object;
		public var itemsHit:Array;
		public var smallStartX1:Number;
		public var bellY:Number;
		public var largeBumperRad:Number;
		public var smallThirdY:Number;
		public var smallStartX2:Number;
		public var gemWidth:Number;
		public var ballPoints:int;
		public var bellX:Number;
		public var lowerTargetState:int;
		public var smallThirdX:Number;
		public var poly:Array;
		public var table:Table;
		public var barrier:Object;
		public var __NOTE:String;
		public var launcherHit:Boolean;
		public var smallStartY2:Number;
		public var rampHeight:Number;
		public var smallStartY1:Number;
		public var topBell:Object;
		public var gemTangent:Number;

		public function MainTimeline(){
			TABLE_TOP = int((TABLE_WIDTH * TABLE_TOP_XSCALE));
			super();
			addFrameScript(0, frame1);
		}
		public function rotateLeft(_arg1:Array){
			var _local2:int;
			var _local3:MovieClip;
			var _local4:int;
			var _local5:MovieClip;
			var _local6:int;
			_local2 = _arg1.length;
			_local4 = _arg1[0].clip.currentFrame;
			_local5 = _arg1[0].clip;
			_local6 = 1;
			while (_local6 < _local2) {
				_local3 = _arg1[_local6].clip;
				_local5.gotoAndStop(_local3.currentFrame);
				_local5 = _local3;
				_local6++;
			};
			_arg1[(_local2 - 1)].clip.gotoAndStop(_local4);
		}
		public function eFrame(_arg1:Event){
			var _local2:int;
			var _local3:int;
			var _local4:MovieClip;
			var _local5:int;
			var _local6:int;
			var _local7:int;
			if (animationID){
				animating();
				return;
			};
			if (table.paused){
				return;
			};
			_local2 = flipper1Frame;
			_local3 = flipper2Frame;
			if (!table.paused){
				if (leftKeys > 0){
					if (flipper1Frame < NUM_FLIPPER_FRAMES){
						flipper1Frame++;
					};
				} else {
					if (flipper1Frame > 0){
						flipper1Frame--;
					};
				};
				if (flipper1Frame != _local2){
					table.updateFlipperAt(flipper1, FLIPPER1_FRAMES[flipper1Frame]);
					flipper1_mc.gotoAndStop((flipper1Frame + 1));
					if (!_local2){
						rotateAllLeft();
					};
				};
				if (rightKeys > 0){
					if (flipper2Frame < NUM_FLIPPER_FRAMES){
						flipper2Frame++;
					};
				} else {
					if (flipper2Frame > 0){
						flipper2Frame--;
					};
				};
				if (flipper2Frame != _local3){
					table.updateFlipperAt(flipper2, FLIPPER2_FRAMES[flipper2Frame]);
					flipper2_mc.gotoAndStop((flipper2Frame + 1));
					if (!_local3){
						rotateAllRight();
					};
				};
			};
			_local4 = entranceDoor.clip;
			if (((entranceDoor.visible) && ((_local4.currentFrame < _local4.totalFrames)))){
				_local4.nextFrame();
			} else {
				if (((!(entranceDoor.visible)) && ((_local4.currentFrame > 1)))){
					_local4.prevFrame();
				};
			};
			_local4 = barrier.clip;
			if (_local4.currentFrame > 1){
				_local4.prevFrame();
			};
			_local4 = bell.clip;
			if (_local4.currentFrame > 1){
				_local4.prevFrame();
			};
			_local4 = topBell.clip;
			if (_local4.currentFrame > 1){
				_local4.prevFrame();
			};
			if ((((((((ball.x < -(TABLE_WIDTH1_2))) || ((ball.x > TABLE_WIDTH1_2)))) || ((ball.y < 0)))) || ((ball.y > TABLE_HEIGHT)))){
				ballEscaped();
			};
			if (keysDown[Keyboard.SPACE]){
				if (launchSpeed < 30){
					launchSpeed++;
					launcher.clip.gotoAndStop(launchSpeed);
				};
			} else {
				if (launchSpeed != 0){
					launcher.clip.gotoAndStop(1);
					launchSpeed = 0;
				};
			};
			disableAllCurrentHitStates();
			if (t > 2){
				fList[((t - 2) % 10000)] = int((1000 / (getTimer() - oldTime)));
				if (fList[(t % 10000)] == 0){
					fList[(t % 10000)] = 50;
				};
				maxF = Math.max(maxF, fList[((t - 2) % 10000)]);
				minF = Math.min(minF, fList[((t - 2) % 10000)]);
				if (!(t % 3)){
					_local5 = 0;
					_local6 = Math.min((t - 2), 10000);
					_local7 = 0;
					while (_local7 < _local6) {
						_local5 = (_local5 + fList[_local7]);
						_local7++;
					};
					_local5 = (_local5 / _local6);
					txt.text = (((((((int(fList[((t - 2) % 10000)]).toString() + "FPS\nMax: ") + maxF.toString()) + "\nMin: ") + minF.toString()) + "\nAVG: ") + _local5.toString()) + "\n");
				};
			};
			oldTime = getTimer();
			t++;
		}
		public function testTopTargets(){
			if (((((targetsA[0].visible) || (targetsA[1].visible))) || (targetsA[2].visible))){
				return;
			};
			activateTopTargets();
		}
		public function rDown(_arg1:Event){
			stage.addEventListener(MouseEvent.MOUSE_MOVE, rMove);
			stage.addEventListener(MouseEvent.MOUSE_UP, rUp);
			oldMX = stage.mouseX;
			oldFrame = reshiram.belly.currentFrame;
		}
		public function activateEntranceDoor(){
			entranceDoor.visible = true;
		}
		public function hitAmberItem(_arg1:Number, _arg2:Number, _arg3:Object, _arg4:Object){
			itemsHit.push(_arg4);
			switch (_arg4){
				case barrier:
					hitBarrier();
					break;
				case bell:
					hitBell();
					break;
				case topBell:
					hitTopBell();
					break;
				case warpEntrance:
					startAnimationMode(WARP_ANIM, new AmberCatchClip(), 0, startWarp, warpFrame, endWarp);
					break;
				case cave:
					testTopTargets();
					if (inflateLight.clip.currentFrame == 2){
						startAnimationMode(INFLATE_ANIM, new AmberInflateClip(), 20, startInflation, inflating, endInflation);
					};
					break;
				case drain:
					loseBall();
					break;
				case launchDetector:
					launcherHit = true;
					break;
				case entranceTrigger1:
				case entranceTrigger2:
				case entranceTrigger3:
					activateEntranceDoor();
					break;
				case bouncySwitch:
					_arg4.counter--;
					if (_arg4.counter <= 0){
						_arg4.counter = 0;
						deactivateBouncySwitch();
					};
					break;
				case lightsA[0]:
				case lightsA[1]:
				case lightsA[2]:
				case lightsA[3]:
					if (!((currentHitState[_arg4]) || (previousHitState[_arg4]))){
						hitLightsA(_arg4);
					};
					setHitState(_arg4);
					break;
				case lightsB[0]:
				case lightsB[1]:
				case lightsB[2]:
					if (!((currentHitState[_arg4]) || (previousHitState[_arg4]))){
						hitLightsB(_arg4);
					};
					setHitState(_arg4);
					break;
				case targetsA[0]:
				case targetsA[1]:
				case targetsA[2]:
					_arg4.visible = false;
					_arg4.clip.visible = false;
					break;
				case targetsB[0]:
				case targetsB[1]:
				case targetsB[2]:
					_arg4.counter--;
					_arg4.clip.gotoAndStop(_arg4.counter);
					if (_arg4.counter <= 0){
						_arg4.counter = 0;
						_arg4.visible = false;
						_arg4.clip.visible = false;
					};
					testBottomTargets();
					break;
				case pathTrigger:
					testTopTargets();
					break;
				case balloonBumpers[0]:
				case balloonBumpers[1]:
				case balloonBumpers[2]:
					hitBalloonBumper(_arg4);
					break;
				case centerBumpers[0]:
				case centerBumpers[1]:
				case centerBumpers[2]:
					hitCenterBumper(_arg4);
					break;
				case sideHoles[0]:
				case sideHoles[1]:
					break;
				default:
					break;
			};
			if ((((ballPoints >= MIN_INFLATION_POINTS)) && ((caveLight.clip.currentFrame == 2)))){
				inflateLight.clip.gotoAndStop(2);
			};
		}
		public function kUp(_arg1:KeyboardEvent){
			var _local2:int;
			var _local3:int;
			_local2 = _arg1.keyCode;
			if (!keysDown[_local2]){
				return;
			};
			keysDown[_local2] = false;
			if (!isNaN(keyMap[_local2])){
				_local3 = keyMap[_local2];
				if (_local3 == flipper1){
					leftKeys--;
				} else {
					if (_local3 == flipper2){
						rightKeys--;
					};
				};
			};
			switch (_local2){
				case Keyboard.SPACE:
					if (launcherHit){
						ball.vY = -(launchSpeed);
					};
					break;
				case Keyboard.TAB:
					table.x = tableDestX;
					panelTop.x = (table.x - (((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE) * 0.5));
					if (tableOffsetX == 5){
						ball.vX = (ball.vX - 2);
					};
					tableOffsetX = 0;
					break;
				case Keyboard.BACKSPACE:
					table.x = tableDestX;
					panelTop.x = (table.x - (((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE) * 0.5));
					if (tableOffsetX == -5){
						ball.vX = (ball.vX + 2);
					};
					tableOffsetX = 0;
					break;
			};
		}
		public function clearAnimationBackground(){
			if (((animationBmp1) && (animationBmp1.parent))){
				animationBmp1.parent.removeChild(animationBmp1);
			};
			if (((animationBmp2) && (animationBmp2.parent))){
				animationBmp2.parent.removeChild(animationBmp2);
			};
			if (animationBGData){
				animationBGData.dispose();
			};
		}
		public function hitCenterBumper(_arg1:Object){
			toggleClip(_arg1);
		}
		public function redrawAnimationBackground(){
			clearAnimationBackground();
			animationBGData = drawMovingBG((animParams.hSpace * Math.ceil((stage.stageWidth / animParams.hSpace))), (stage.stageHeight * (200 / 600)), animParams.hRadius, animParams.vRadius, animParams.hSpace, animParams.vSpace, animParams.hOffset, animParams.vOffset, animParams.color, animParams.bgColor);
			animationBmp1 = new Bitmap(animationBGData);
			animationBmp2 = new Bitmap(animationBGData);
			animationBG.addChildAt(animationBmp1, 0);
			animationBG.addChildAt(animationBmp2, 0);
			animationBmp1.x = 0;
			animationBmp2.x = animationBGData.width;
			animationBmp1.y = (animationBmp2.y = (-(animationBGData.height) * 0.5));
		}
		function frame1(){
			stop();
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			cMenu = new ContextMenu();
			cMenu.hideBuiltInItems();
			this.contextMenu = cMenu;
			pauseClip = new TextField();
			pauseClip.defaultTextFormat = new TextFormat("Arial", 24, 0xFF0000, true);
			pauseClip.textColor = 0xFF0000;
			pauseClip.border = true;
			pauseClip.background = true;
			pauseClip.text = "PAUSED";
			pauseClip.width = (pauseClip.textWidth + 5);
			pauseClip.height = (pauseClip.textHeight + 5);
			pauseClip.x = ((STAGE_WIDTH - pauseClip.width) * 0.5);
			pauseClip.y = ((STAGE_HEIGHT - pauseClip.height) * 0.5);
			trace("Erase the while loop (and M key)");
			trace("Remove domain protection and secret items from library.");
			trace("Remove pause rectangle");
			trace("improve instructions page");
			oldMX = 0;
			oldFrame = 1;
			if (new LocalConnection().domain.indexOf("deviantart") < 0){
				while (numChildren) {
					removeChildAt(0);
				};
				reshiram = new Reshiram();
				stage.addChild(reshiram);
				reshiram.x = (stage.stageWidth * 0.5);
				reshiram.y = (stage.stageHeight * 0.5);
				reshiram.belly.stop();
				stage.addEventListener(MouseEvent.MOUSE_DOWN, rDown);
				stage.addEventListener(Event.RESIZE, function (_arg1:MouseEvent){
					reshiram.x = (stage.stageWidth * 0.5);
					reshiram.y = (stage.stageHeight * 0.5);
				});
				return;
			};
			__NOTE = "Demo";
			bumperRad = (0.0583 * TABLE_WIDTH1_2);
			bigBumperRad = (0.066 * TABLE_WIDTH1_2);
			largeBumperRad = (0.1 * TABLE_WIDTH1_2);
			MAX_FLIPPER_ANGLE = (-(Math.PI) * 0.25);
			FLIPPER1_FRAMES = [];
			FLIPPER2_FRAMES = [];
			amberTable = new Table();
			dragonAmberTable = new Table();
			table = amberTable;
			flipper1_mc = new flipperLeft_mc();
			flipper2_mc = new flipperRight_mc();
			tableDestX = 0;
			tableDestY = 0;
			tableOffsetX = 0;
			tableOffsetY = 0;
			balloonBumpers = [];
			centerBumpers = [];
			targetsA = [];
			targetsB = [];
			lightsA = [];
			lightsB = [];
			triangles = [];
			sideHoles = [];
			bgClip = new MovieClip();
			panelRight = new MovieClip();
			panelTop = new MovieClip();
			leftKeys = 0;
			rightKeys = 0;
			flipper1Frame = 0;
			flipper2Frame = 0;
			keyMap = [];
			keysDown = [];
			itemsHit = [];
			launcherHit = false;
			launchSpeed = 0;
			lightState = 0;
			topLightState = 0;
			lowerTargetState = 0;
			upperTargetState = 0;
			goldApples = 0;
			ballPoints = 0;
			inflationPoints = 0;
			tablePoints = 0;
			animationID = 0;
			animationState = 0;
			animationContainer = new MovieClip();
			animationTimer = 0;
			animParams = new Object();
			animationBG = new MovieClip();
			holeWidth = (0.208 * TABLE_WIDTH1_2);
			rampWidth = holeWidth;
			holeHeight = (TABLE_HEIGHT * 0.178);
			rampHeight = (0.233 * TABLE_HEIGHT);
			wallHeight = (0.422 * TABLE_HEIGHT);
			wallWidth = (0.045 * TABLE_WIDTH);
			sideHeight = (0.078 * TABLE_HEIGHT);
			sideWidth = (0.041 * TABLE_WIDTH);
			halfHeight = (0.5 * TABLE_HEIGHT);
			remainingWidth = (TABLE_WIDTH1_2 - (((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth));
			warpWidth = (0.075 * TABLE_WIDTH);
			entranceHeight = (0.75 * TABLE_HEIGHT);
			entranceWallWidth = (0.025 * TABLE_WIDTH);
			entranceWidth = (TABLE_WIDTH1_2 - (((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + warpWidth) + entranceWallWidth));
			remainingHeight = (sideHeight + (remainingWidth * 0.5));
			bouncyHeight = ((TABLE_HEIGHT - remainingHeight) - halfHeight);
			bouncyThird = (bouncyHeight / 3);
			bouncyWidth = (entranceWallWidth * 0.5);
			bouncyHeight2 = entranceWallWidth;
			gemCenterX = (0.167 * TABLE_WIDTH1_2);
			gemCenterY = (0.288 * TABLE_HEIGHT);
			gemEndX = (((rampWidth + holeWidth) + wallWidth) + (sideWidth * 0.5));
			gemHeight = (0.14 * TABLE_HEIGHT);
			gemHeight2 = (0.095 * TABLE_HEIGHT);
			gemMidX = (rampWidth + holeWidth);
			gemWidth = (gemMidX - gemCenterX);
			gemTangent = (gemHeight / gemWidth);
			invGemTangent = (1 / gemTangent);
			gemProp1 = 0.45;
			gemProp2 = 0.8;
			gemDepth = 0.6;
			leftGemProp1 = 0.6;
			leftGemProp2 = 0.6;
			previousHitState = new Dictionary();
			currentHitState = new Dictionary();
			bottomWidth = (TABLE_WIDTH1_2 * tableScaleX(TABLE_HEIGHT));
			topWidth = (TABLE_WIDTH1_2 * tableScaleX(0));
			table.addWall(-(topWidth), 0, topWidth, 0, 0, new MovieClip(), WALL_MULT);
			table.addWall(topWidth, 0, bottomWidth, TABLE_HEIGHT, 0, new MovieClip(), WALL_MULT);
			table.addWall(bottomWidth, TABLE_HEIGHT, -(bottomWidth), TABLE_HEIGHT, 0, new MovieClip(), WALL_MULT);
			table.addWall(-(bottomWidth), TABLE_HEIGHT, -(topWidth), 0, 0, new MovieClip(), WALL_MULT);
			poly = [];
			poly[poly.length] = {x:(-(holeWidth) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			poly[poly.length] = {x:(-(holeWidth) * tableScaleX((TABLE_HEIGHT - holeHeight))), y:(TABLE_HEIGHT - holeHeight)};
			poly[poly.length] = {x:(-((rampWidth + holeWidth)) * tableScaleX((TABLE_HEIGHT - rampHeight))), y:(TABLE_HEIGHT - rampHeight)};
			poly[poly.length] = {x:(-((rampWidth + holeWidth)) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(-(((rampWidth + holeWidth) + wallWidth)) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(-(((rampWidth + holeWidth) + wallWidth)) * tableScaleX((TABLE_HEIGHT - sideHeight))), y:(TABLE_HEIGHT - sideHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((TABLE_HEIGHT - sideHeight))), y:(TABLE_HEIGHT - sideHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((((TABLE_HEIGHT - halfHeight) + bouncyHeight) + bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + bouncyHeight) + bouncyHeight2)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth)) * tableScaleX(((TABLE_HEIGHT - halfHeight) + bouncyHeight))), y:((TABLE_HEIGHT - halfHeight) + bouncyHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth)) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			poly = poly.reverse();
			curItem = table.addPolygon(poly, new leftCenter_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) + (bouncyHeight2 * 2)))), y:(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) + (bouncyHeight2 * 2))};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			poly[poly.length] = {x:((-(gemEndX) + wallWidth) * tableScaleX((gemCenterY + gemHeight2))), y:(gemCenterY + gemHeight2)};
			poly[poly.length] = {x:(-(gemEndX) * tableScaleX((gemCenterY + gemHeight2))), y:(gemCenterY + gemHeight2)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth)) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth)) * tableScaleX(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)))), y:((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2))};
			poly = poly.reverse();
			curItem = table.addPolygon(poly, new partyEntrance_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(-(holeWidth) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			poly[poly.length] = {x:(-(holeWidth) * tableScaleX((TABLE_HEIGHT - holeHeight))), y:(TABLE_HEIGHT - holeHeight)};
			poly[poly.length] = {x:(-((rampWidth + holeWidth)) * tableScaleX((TABLE_HEIGHT - rampHeight))), y:(TABLE_HEIGHT - rampHeight)};
			poly[poly.length] = {x:(-((rampWidth + holeWidth)) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(-(((rampWidth + holeWidth) + wallWidth)) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(-(((rampWidth + holeWidth) + wallWidth)) * tableScaleX((TABLE_HEIGHT - sideHeight))), y:(TABLE_HEIGHT - sideHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((TABLE_HEIGHT - sideHeight))), y:(TABLE_HEIGHT - sideHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + wallWidth) + sideWidth)) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			poly[poly.length] = {x:(-((((rampWidth + holeWidth) + (2 * wallWidth)) + sideWidth)) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			i = 0;
			while (i < poly.length) {
				poly[i].x = -(poly[i].x);
				i++;
			};
			poly[poly.length] = {x:((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)))), y:((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5))};
			poly[poly.length] = {x:(((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + warpWidth) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)))), y:((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5))};
			poly[poly.length] = {x:(((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + warpWidth) * tableScaleX((TABLE_HEIGHT - entranceHeight))), y:(TABLE_HEIGHT - entranceHeight)};
			poly[poly.length] = {x:((((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + warpWidth) + entranceWallWidth) * tableScaleX((TABLE_HEIGHT - entranceHeight))), y:(TABLE_HEIGHT - entranceHeight)};
			poly[poly.length] = {x:((((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + warpWidth) + entranceWallWidth) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			curItem = table.addPolygon(poly, new rightCenter_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX(0)), y:0};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + (TABLE_HEIGHT - entranceHeight)) * tableScaleX(0)), y:0};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + entranceWidth) * tableScaleX(entranceWidth)), y:entranceWidth};
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX((TABLE_HEIGHT - entranceHeight))), y:(TABLE_HEIGHT - entranceHeight)};
			curItem = table.addPolygon(poly, new leftCorner_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly = poly.reverse();
			i = 0;
			while (i < poly.length) {
				poly[i].x = -(poly[i].x);
				i++;
			};
			curItem = table.addPolygon(poly, new rightCorner_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			table.addBumper((-(((-(TABLE_WIDTH1_2) + remainingWidth) + (wallWidth * 0.5))) * tableScaleX((TABLE_HEIGHT - halfHeight))), (TABLE_HEIGHT - halfHeight), ((wallWidth * 0.5) * tableScaleX((TABLE_HEIGHT - halfHeight))), new MovieClip(), WALL_MULT);
			table.addBumper((((rampWidth + holeWidth) + (wallWidth * 0.5)) * tableScaleX((TABLE_HEIGHT - wallHeight))), (TABLE_HEIGHT - wallHeight), ((wallWidth * 0.5) * tableScaleX((TABLE_HEIGHT - wallHeight))), new MovieClip(), WALL_MULT);
			table.addBumper((-(((rampWidth + holeWidth) + (wallWidth * 0.5))) * tableScaleX((TABLE_HEIGHT - wallHeight))), (TABLE_HEIGHT - wallHeight), ((wallWidth * 0.5) * tableScaleX((TABLE_HEIGHT - wallHeight))), new MovieClip(), WALL_MULT);
			table.addBumper((((TABLE_WIDTH1_2 - entranceWidth) - (entranceWallWidth * 0.5)) * tableScaleX((TABLE_HEIGHT - entranceHeight))), (TABLE_HEIGHT - entranceHeight), ((entranceWallWidth * 0.5) * tableScaleX((TABLE_HEIGHT - entranceHeight))), new MovieClip(), WALL_MULT);
			poly.length = 0;
			poly[poly.length] = {x:(-(gemCenterX) * tableScaleX(gemCenterY)), y:gemCenterY};
			poly[poly.length] = {x:(-((gemCenterX + (leftGemProp2 * gemWidth))) * tableScaleX((gemCenterY + (gemHeight * leftGemProp2)))), y:(gemCenterY + (gemHeight * leftGemProp2))};
			poly[poly.length] = {x:((-(gemCenterX) - ((gemWidth + bigBumperRad) * leftGemProp1)) * tableScaleX(gemCenterY)), y:gemCenterY};
			poly[poly.length] = {x:(-(((gemCenterX + (leftGemProp1 * gemWidth)) + 1)) * tableScaleX(((gemCenterY - (gemHeight * leftGemProp1)) + 1))), y:((gemCenterY - (gemHeight * leftGemProp1)) + 1)};
			poly[poly.length] = {x:(-((gemCenterX + (leftGemProp1 * gemWidth))) * tableScaleX((gemCenterY - (gemHeight * leftGemProp1)))), y:(gemCenterY - (gemHeight * leftGemProp1))};
			table.addPolygon(poly, new MovieClip(), WALL_MULT);
			poly.length = 0;
			poly[poly.length] = {x:(-(gemMidX) * tableScaleX((gemCenterY + gemHeight))), y:(gemCenterY + gemHeight)};
			poly[poly.length] = {x:(-(gemEndX) * tableScaleX((gemCenterY + gemHeight2))), y:(gemCenterY + gemHeight2)};
			poly[poly.length] = {x:(-(gemEndX) * tableScaleX((gemCenterY - gemHeight2))), y:(gemCenterY - gemHeight2)};
			poly[poly.length] = {x:(-(gemMidX) * tableScaleX((gemCenterY - gemHeight))), y:(gemCenterY - gemHeight)};
			poly[poly.length] = {x:((-(gemMidX) + 1) * tableScaleX(((gemCenterY - gemHeight) + 1))), y:((gemCenterY - gemHeight) + 1)};
			poly[poly.length] = {x:((-(gemMidX) - bigBumperRad) * tableScaleX(gemCenterY)), y:gemCenterY};
			curItem = table.addPolygon(poly, new gemLeft_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(gemCenterX * tableScaleX(gemCenterY)), y:gemCenterY};
			poly[poly.length] = {x:(gemMidX * tableScaleX((gemCenterY - gemHeight))), y:(gemCenterY - gemHeight)};
			poly[poly.length] = {x:(gemEndX * tableScaleX((gemCenterY - gemHeight2))), y:(gemCenterY - gemHeight2)};
			poly[poly.length] = {x:(gemEndX * tableScaleX((gemCenterY + gemHeight2))), y:(gemCenterY + gemHeight2)};
			poly[poly.length] = {x:(gemMidX * tableScaleX((gemCenterY + gemHeight))), y:(gemCenterY + gemHeight)};
			poly[poly.length] = {x:((gemCenterX + (gemProp2 * gemWidth)) * tableScaleX((gemCenterY + ((gemWidth * gemProp2) * gemTangent)))), y:(gemCenterY + ((gemWidth * gemProp2) * gemTangent))};
			poly[poly.length] = {x:((gemCenterX + ((gemProp2 + gemDepth) * gemWidth)) * tableScaleX((gemCenterY + (((gemProp2 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)))), y:(gemCenterY + (((gemProp2 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth))};
			poly[poly.length] = {x:((gemCenterX + ((gemProp1 + gemDepth) * gemWidth)) * tableScaleX((gemCenterY + (((gemProp1 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)))), y:(gemCenterY + (((gemProp1 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth))};
			poly[poly.length] = {x:((gemCenterX + (gemProp1 * gemWidth)) * tableScaleX((gemCenterY + ((gemWidth * gemProp2) * gemTangent)))), y:(gemCenterY + ((gemWidth * gemProp1) * gemTangent))};
			curItem = table.addPolygon(poly, new gemRight_mc(), WALL_MULT);
			curItem.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(-(gemCenterX) * tableScaleX(gemCenterY)), y:gemCenterY};
			poly[poly.length] = {x:(gemCenterX * tableScaleX(gemCenterY)), y:gemCenterY};
			poly[poly.length] = {x:((gemCenterX + bumperRad) * tableScaleX((gemCenterY + (bumperRad * gemTangent)))), y:(gemCenterY + (bumperRad * gemTangent))};
			poly[poly.length] = {x:(-((gemCenterX + bumperRad)) * tableScaleX((gemCenterY + (bumperRad * gemTangent)))), y:(gemCenterY + (bumperRad * gemTangent))};
			cornerWallProp1 = 0.45;
			cornerWallProp2 = 0.6;
			cornerWallX1 = ((((TABLE_WIDTH1_2 - entranceWidth) - (entranceWallWidth * 0.5)) * cornerWallProp1) + (gemEndX * (1 - cornerWallProp1)));
			cornerWallY1 = (((TABLE_HEIGHT - entranceHeight) * cornerWallProp1) + (((gemCenterY - gemHeight) - (bumperRad * 1.5)) * (1 - cornerWallProp1)));
			cornerWallX2 = ((((TABLE_WIDTH1_2 - entranceWidth) - (entranceWallWidth * 0.5)) * cornerWallProp2) + (gemEndX * (1 - cornerWallProp2)));
			cornerWallY2 = (((TABLE_HEIGHT - entranceHeight) * cornerWallProp2) + (((gemCenterY - gemHeight) - (bumperRad * 1.5)) * (1 - cornerWallProp2)));
			curItem = table.addWall((cornerWallX1 * tableScaleX(cornerWallY1)), cornerWallY1, (cornerWallX2 * tableScaleX(cornerWallY2)), cornerWallY2, (entranceWallWidth * 0.5), new thickBar_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			smallStartX1 = -(gemMidX);
			smallEndX1 = (-(TABLE_WIDTH1_2) + (TABLE_HEIGHT - entranceHeight));
			smallStartY1 = (gemCenterY - gemHeight);
			smallEndY1 = 0;
			smallStartX2 = -(gemEndX);
			smallEndX2 = (smallEndX1 + (smallStartX2 - smallStartX2));
			smallStartY2 = (gemCenterY - gemHeight2);
			smallEndY2 = (smallEndY1 + (smallStartY2 - smallStartY1));
			smallThirdX = ((smallEndX1 - smallStartX1) / 3);
			smallThirdY = ((smallEndY1 - smallStartY1) / 3);
			smallThickness = 0.1;
			poly.length = 0;
			poly[poly.length] = {x:(((smallStartX2 + smallThirdX) + 1) * tableScaleX(((smallStartY2 + smallThirdY) + 2))), y:((smallStartY2 + smallThirdY) + 2)};
			poly[poly.length] = {x:(((smallStartX2 + smallThirdX) - 1) * tableScaleX(((smallStartY2 + smallThirdY) - 2))), y:((smallStartY2 + smallThirdY) - 2)};
			poly[poly.length] = {x:(((smallStartX1 + smallThirdX) - 1) * tableScaleX(((smallStartX1 + smallThirdY) - 2))), y:((smallStartY1 + smallThirdY) - 2)};
			poly[poly.length] = {x:(((smallStartX1 + smallThirdX) + 1) * tableScaleX(((smallStartX1 + smallThirdY) + 2))), y:((smallStartY1 + smallThirdY) + 2)};
			curItem = table.addPolygon(poly, new thinBar_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			i = 0;
			while (i < poly.length) {
				poly[i].x = (poly[i].x + smallThirdX);
				poly[i].y = (poly[i].y + smallThirdY);
				i++;
			};
			curItem = table.addPolygon(poly, new thinBar_mc(), WALL_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			goldBumper = (curItem = table.addBumper((gemEndX * tableScaleX(((gemCenterY - gemHeight) - (bumperRad * 1.5)))), ((gemCenterY - gemHeight) - (bumperRad * 1.5)), (bumperRad * tableScaleX(((gemCenterY - gemHeight) - (bumperRad * 1.5)))), new goldBumper_mc(), BUMPER_MULT));
			goldBumper.bounce = true;
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			centerBumperTop = ((2 * bumperRad) + (0.5 * bumperRad));
			centerBumperBottom = (((gemCenterY - (gemHeight * 0.5)) - (bumperRad * Math.SQRT2)) + (0.5 * bumperRad));
			centerBumpers[centerBumpers.length] = (curItem = table.addBumper((-(gemCenterX) * tableScaleX(centerBumperTop)), centerBumperTop, (bumperRad * tableScaleX(centerBumperTop)), new redTopBumper_mc(), BUMPER_MULT));
			curItem.bounce = true;
			centerBumpers[centerBumpers.length] = (curItem = table.addBumper((0 * tableScaleX(centerBumperBottom)), centerBumperBottom, (bumperRad * tableScaleX(centerBumperBottom)), new greenTopBumper_mc(), BUMPER_MULT));
			curItem.bounce = true;
			centerBumpers[centerBumpers.length] = (curItem = table.addBumper((gemCenterX * tableScaleX(centerBumperTop)), centerBumperTop, (bumperRad * tableScaleX(centerBumperTop)), new blueTopBumper_mc(), BUMPER_MULT));
			curItem.bounce = true;
			leftAreaWidth = (TABLE_WIDTH1_2 - gemEndX);
			leftAreaSpace = (leftAreaWidth - ((bumperRad * 2) * 2));
			leftAreaThird = (leftAreaSpace / 3);
			balloonBumpers[balloonBumpers.length] = (curItem = table.addBumper(((-(TABLE_WIDTH1_2) + (leftAreaWidth * 0.5)) * tableScaleX(((gemCenterY - gemHeight2) + bumperRad))), ((gemCenterY - gemHeight2) + bumperRad), (bumperRad * tableScaleX(((gemCenterY - gemHeight2) + bumperRad))), new redBalloonBumper_mc(), BUMPER_MULT));
			balloonBumpers[balloonBumpers.length] = (curItem = table.addBumper(((((-(TABLE_WIDTH1_2) + (leftAreaWidth * 0.5)) + (leftAreaThird * 0.5)) + bumperRad) * tableScaleX(((gemCenterY + gemHeight2) - bumperRad))), ((gemCenterY + gemHeight2) - bumperRad), (bumperRad * tableScaleX(((gemCenterY + gemHeight2) - bumperRad))), new blueBalloonBumper_mc(), BUMPER_MULT));
			balloonBumpers[balloonBumpers.length] = (curItem = table.addBumper(((((-(TABLE_WIDTH1_2) + (leftAreaWidth * 0.5)) - (leftAreaThird * 0.5)) - bumperRad) * tableScaleX(((gemCenterY + gemHeight2) - bumperRad))), ((gemCenterY + gemHeight2) - bumperRad), (bumperRad * tableScaleX(((gemCenterY + gemHeight2) - bumperRad))), new greenBalloonBumper_mc(), BUMPER_MULT));
			triangleCornerHeight = (((rampHeight - holeHeight) * (rampWidth - sideWidth)) / rampWidth);
			triangleFrontX = (holeWidth + (entranceWidth * 0.5));
			triangleFrontY = (((TABLE_HEIGHT - holeHeight) - sideWidth) - (((rampHeight - holeHeight) * (entranceWidth * 0.5)) / rampWidth));
			poly.length = 0;
			poly[poly.length] = {x:(triangleFrontX * tableScaleX(triangleFrontY)), y:triangleFrontY};
			poly[poly.length] = {x:((((holeWidth + rampWidth) - sideWidth) - 2) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(((holeWidth + rampWidth) - sideWidth) * tableScaleX((TABLE_HEIGHT - wallHeight))), y:(TABLE_HEIGHT - wallHeight)};
			poly[poly.length] = {x:(((holeWidth + rampWidth) - sideWidth) * tableScaleX((((TABLE_HEIGHT - holeHeight) - sideWidth) - triangleCornerHeight))), y:(((TABLE_HEIGHT - holeHeight) - sideWidth) - triangleCornerHeight)};
			triangles[0] = (curItem = table.addPolygon(poly, new triangleRight_mc(), BUMPER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly = poly.reverse();
			i = 0;
			while (i < poly.length) {
				poly[i].x = -(poly[i].x);
				i++;
			};
			triangles[0] = (curItem = table.addPolygon(poly, new triangleLeft_mc(), BUMPER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + bouncyThird) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + bouncyThird) - bouncyHeight2)};
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX(((TABLE_HEIGHT - halfHeight) + bouncyThird))), y:((TABLE_HEIGHT - halfHeight) + bouncyThird)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) - bouncyHeight2)};
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)))), y:((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2))};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3)) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3)) - bouncyHeight2)};
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX((TABLE_HEIGHT - remainingHeight))), y:(TABLE_HEIGHT - remainingHeight)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + (remainingWidth * 0.5)) * tableScaleX((TABLE_HEIGHT - sideHeight))), y:(TABLE_HEIGHT - sideHeight)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX((TABLE_HEIGHT - remainingHeight))), y:(TABLE_HEIGHT - remainingHeight)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			poly[poly.length] = {x:(-(TABLE_WIDTH1_2) * tableScaleX(TABLE_HEIGHT)), y:TABLE_HEIGHT};
			curItem = table.addPolygon(poly, new bouncyLeft_mc(), BOUNCY_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)))), y:((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2))};
			poly[poly.length] = {x:(((-(TABLE_WIDTH1_2) + remainingWidth) - bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)) - bouncyHeight2)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX(((TABLE_HEIGHT - halfHeight) + bouncyThird))), y:((TABLE_HEIGHT - halfHeight) + bouncyThird)};
			poly[poly.length] = {x:(((-(TABLE_WIDTH1_2) + remainingWidth) - bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + bouncyThird) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + bouncyThird) - bouncyHeight2)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX((TABLE_HEIGHT - halfHeight))), y:(TABLE_HEIGHT - halfHeight)};
			curItem = table.addPolygon(poly, new bouncyRight_mc(), BOUNCY_MULT);
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			starX = (0.5 * (((gemEndX + TABLE_WIDTH1_2) - entranceWallWidth) - entranceWidth));
			starY = gemCenterY;
			starRadius = ((((TABLE_WIDTH1_2 - entranceWallWidth) - entranceWidth) - gemEndX) * 0.25);
			sideHoles[sideHoles.length] = (curItem = table.addWall(((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - sideHeight) + 1))), ((TABLE_HEIGHT - sideHeight) + 1), ((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - sideHeight) - 1))), ((TABLE_HEIGHT - sideHeight) - 1), (sideWidth * 0.5), new sideHole_mc(), SHOOTER_MULT));
			curItem.bounce = true;
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			sideHoles[sideHoles.length] = (curItem = table.addWall((-((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5))) * tableScaleX(((TABLE_HEIGHT - sideHeight) + 1))), ((TABLE_HEIGHT - sideHeight) + 1), (-((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5))) * tableScaleX(((TABLE_HEIGHT - sideHeight) - 1))), ((TABLE_HEIGHT - sideHeight) - 1), (sideWidth * 0.5), new sideHole_mc(), SHOOTER_MULT));
			curItem.bounce = true;
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			warpEntrance = (curItem = table.addTrigger(((((TABLE_WIDTH1_2 - entranceWidth) - entranceWallWidth) - (warpWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)))), ((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)), (warpWidth * 0.5), new warp_mc()));
			cave = table.addTrigger(((((gemCenterX + ((gemProp2 + gemDepth) * gemWidth)) * tableScaleX((gemCenterY + (((gemProp2 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)))) * 0.5) + (((gemCenterX + ((gemProp1 + gemDepth) * gemWidth)) * tableScaleX((gemCenterY + (((gemProp1 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)))) * 0.5)), (((gemCenterY + (((gemProp2 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)) * 0.5) + ((gemCenterY + (((gemProp1 * gemTangent) - (gemDepth * invGemTangent)) * gemWidth)) * 0.5)), (sideWidth * 0.5), new MovieClip());
			caveEntranceY = (gemCenterY + (((gemWidth * (gemProp1 + gemProp2)) * 0.5) * gemTangent));
			caveEntranceX = (gemCenterX + (((gemProp1 + gemProp2) * 0.5) * gemWidth));
			caveLight = table.addTrigger((caveEntranceX * tableScaleX(caveEntranceY)), caveEntranceY, 1, new caveLight_mc());
			inflateLight = table.addTrigger((caveEntranceX - (bumperRad * tableScaleX((caveEntranceY + bumperRad)))), (caveEntranceY + bumperRad), 1, new inflateLight_mc());
			barrier = table.addBumper((((((holeWidth + rampWidth) + (2 * wallWidth)) + sideWidth) + (warpWidth * 0.5)) * tableScaleX((TABLE_HEIGHT - halfHeight))), (TABLE_HEIGHT - halfHeight), (bumperRad * tableScaleX((TABLE_HEIGHT - halfHeight))), new barrier_mc(), SHOOTER_MULT);
			barrier.bounce = true;
			drain = table.addWall((-(holeWidth) * tableScaleX(TABLE_HEIGHT)), TABLE_HEIGHT, (holeWidth * tableScaleX(TABLE_HEIGHT)), TABLE_HEIGHT, 5, new MovieClip(), WALL_MULT);
			entranceTrigger1 = table.addTrigger(((TABLE_WIDTH1_2 - (entranceWidth * 2.5)) * tableScaleX(entranceWidth)), entranceWidth, (entranceWidth * 0.5), new MovieClip());
			entranceTrigger2 = table.addTrigger(((TABLE_WIDTH1_2 - (entranceWidth * 3)) * tableScaleX((entranceWidth * 2))), (entranceWidth * 2), (entranceWidth * 0.5), new MovieClip());
			entranceTrigger3 = table.addTrigger(((TABLE_WIDTH1_2 - (entranceWidth * 2.4)) * tableScaleX((entranceWidth * 3))), (entranceWidth * 3), (entranceWidth * 0.5), new MovieClip());
			entranceDoor = table.addWall((((TABLE_WIDTH1_2 - entranceWidth) - (entranceWallWidth * 0.25)) * tableScaleX((TABLE_HEIGHT - entranceHeight))), ((TABLE_HEIGHT - entranceHeight) - (entranceWallWidth * 0.25)), ((((TABLE_WIDTH1_2 - entranceWidth) - entranceWallWidth) + entranceWidth) * tableScaleX((TABLE_HEIGHT - entranceHeight))), ((TABLE_HEIGHT - entranceHeight) - entranceWidth), (entranceWallWidth * 0.5), new entranceDoor_mc(), WALL_MULT);
			bellX = (((gemCenterX + (gemProp2 * gemWidth)) + gemMidX) * 0.5);
			bellY = (((gemCenterY + ((gemWidth * gemProp2) * gemTangent)) + (gemCenterY + gemHeight)) * 0.5);
			bell = table.addBumper((bellX * tableScaleX(bellY)), bellY, (Math.sqrt((((gemMidX - bellX) * (gemMidX - bellX)) + (((gemCenterY + gemHeight) - bellY) * ((gemCenterY + gemHeight) - bellY)))) * tableScaleX(bellY)), new bell_mc(), BUMPER_MULT);
			topBell = table.addBumper(0, 0, (bumperRad * 0.5), new topBell_mc(), BUMPER_MULT);
			centerWidth = (gemCenterX * 2);
			centerSpace = (centerWidth * 0.3);
			centerThird = ((centerWidth - centerSpace) / 3);
			centerTargetHeight = (bumperRad * 0.25);
			centerTargetWidth = (centerThird - (2 * centerTargetHeight));
			centerTargetPos = (centerThird + (centerSpace / 4));
			targetsAY = (gemCenterY - centerTargetHeight);
			tempTargetBY = ((gemCenterY + bumperRad) + (centerTargetHeight * 0.5));
			tempTargetBW = (centerTargetPos * 0.5);
			targetsA[0] = (curItem = table.addWall(((-(centerTargetPos) - (centerTargetWidth * 0.5)) * tableScaleX(targetsAY)), targetsAY, ((-(centerTargetPos) + (centerTargetWidth * 0.5)) * tableScaleX(targetsAY)), targetsAY, centerTargetHeight, new targetA_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly = [];
			poly[poly.length] = {x:(-(tempTargetBW) * tableScaleX(targetsAY)), y:targetsAY};
			poly[poly.length] = {x:(0 * tableScaleX((targetsAY - tempTargetBW))), y:(targetsAY - tempTargetBW)};
			poly[poly.length] = {x:(tempTargetBW * tableScaleX(targetsAY)), y:targetsAY};
			poly[poly.length] = {x:(0 * tableScaleX((targetsAY + tempTargetBW))), y:(targetsAY + tempTargetBW)};
			targetsA[1] = (curItem = table.addPolygon(poly, new targetASquare_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			targetsA[2] = (curItem = table.addWall(((centerTargetPos - (centerTargetWidth * 0.5)) * tableScaleX(targetsAY)), targetsAY, ((centerTargetPos + (centerTargetWidth * 0.5)) * tableScaleX(targetsAY)), targetsAY, centerTargetHeight, new targetA_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly = [];
			poly[poly.length] = {x:((-(centerTargetPos) - tempTargetBW) * tableScaleX(tempTargetBY)), y:tempTargetBY};
			poly[poly.length] = {x:(-(centerTargetPos) * tableScaleX((tempTargetBY - tempTargetBW))), y:(tempTargetBY - tempTargetBW)};
			poly[poly.length] = {x:((-(centerTargetPos) + tempTargetBW) * tableScaleX(tempTargetBY)), y:tempTargetBY};
			poly[poly.length] = {x:(-(centerTargetPos) * tableScaleX((tempTargetBY + tempTargetBW))), y:(tempTargetBY + tempTargetBW)};
			targetsB[0] = (curItem = table.addPolygon(poly, new targetBCircle_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			i = 0;
			while (i < 4) {
				poly[i].x = -(poly[i].x);
				i++;
			};
			targetsB[2] = (curItem = table.addPolygon(poly, new targetBCircle_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly = [];
			poly[poly.length] = {x:(-(tempTargetBW) * tableScaleX((tempTargetBY + centerTargetPos))), y:(tempTargetBY + centerTargetPos)};
			poly[poly.length] = {x:(0 * tableScaleX(((tempTargetBY + centerTargetPos) - tempTargetBW))), y:((tempTargetBY + centerTargetPos) - tempTargetBW)};
			poly[poly.length] = {x:(tempTargetBW * tableScaleX((tempTargetBY + centerTargetPos))), y:(tempTargetBY + centerTargetPos)};
			poly[poly.length] = {x:(0 * tableScaleX(((tempTargetBY + centerTargetPos) + tempTargetBW))), y:((tempTargetBY + centerTargetPos) + tempTargetBW)};
			targetsB[1] = (curItem = table.addPolygon(poly, new targetBCircle_mc(), SHOOTER_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			poly.length = 0;
			poly[poly.length] = {x:(((-(TABLE_WIDTH1_2) + remainingWidth) - bouncyWidth) * tableScaleX((((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3)) - bouncyHeight2))), y:(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3)) - bouncyHeight2)};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3)))), y:((TABLE_HEIGHT - halfHeight) + (bouncyThird * 3))};
			poly[poly.length] = {x:((-(TABLE_WIDTH1_2) + remainingWidth) * tableScaleX(((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2)))), y:((TABLE_HEIGHT - halfHeight) + (bouncyThird * 2))};
			poly = poly.reverse();
			bouncySwitch = (curItem = table.addPolygon(poly, new bouncySwitch_mc(), BOUNCY_MULT));
			curItem.clip.cacheAsBitmap = BITMAP_CACHING;
			launcher = table.addWall(((TABLE_WIDTH1_2 - (bumperRad * 0.5)) * tableScaleX((TABLE_HEIGHT - (bumperRad * 0.5)))), (TABLE_HEIGHT - (bumperRad * 0.5)), (((TABLE_WIDTH1_2 - entranceWidth) + (bumperRad * 0.5)) * tableScaleX((TABLE_HEIGHT - (bumperRad * 0.5)))), (TABLE_HEIGHT - (bumperRad * 0.5)), (bumperRad * 0.5), new launcher_mc(), WALL_MULT);
			launchDetector = table.addTrigger(((TABLE_WIDTH1_2 - (entranceWidth * 0.5)) * tableScaleX((TABLE_HEIGHT - (entranceWidth * 0.5)))), (TABLE_HEIGHT - (entranceWidth * 0.5)), ((entranceWidth * 0.5) * tableScaleX((TABLE_HEIGHT - (entranceWidth * 0.5)))), new MovieClip());
			lightsARadius = ((sideWidth * 0.3) * tableScaleX(((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5))));
			lightsA[lightsA.length] = table.addTrigger((-((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5))) * tableScaleX(((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)))), ((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)), lightsARadius, new lightsA_mc());
			lightsA[lightsA.length] = table.addTrigger((-(((holeWidth + rampWidth) - (sideWidth * 0.5))) * tableScaleX(((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)))), ((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)), lightsARadius, new lightsA_mc());
			lightsA[lightsA.length] = table.addTrigger((((holeWidth + rampWidth) - (sideWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)))), ((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)), lightsARadius, new lightsA_mc());
			lightsA[lightsA.length] = table.addTrigger(((((holeWidth + rampWidth) + wallWidth) + (sideWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)))), ((TABLE_HEIGHT - wallHeight) + (sideWidth * 0.5)), lightsARadius, new lightsA_mc());
			lightsBRadius = Math.abs((smallThirdY * 0.33));
			lightsB[lightsB.length] = table.addTrigger(((((smallStartX1 + smallStartX2) * 0.5) + (smallThirdX * 0.5)) * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 0.5)))), (((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 0.5)), (lightsBRadius * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 2.5)))), new lightsA_mc());
			lightsB[lightsB.length] = table.addTrigger(((((smallStartX1 + smallStartX2) * 0.5) + (smallThirdX * 1.5)) * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 1.5)))), (((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 1.5)), (lightsBRadius * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 2.5)))), new lightsA_mc());
			lightsB[lightsB.length] = table.addTrigger(((((smallStartX1 + smallStartX2) * 0.5) + (smallThirdX * 2.5)) * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 2.5)))), (((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 2.5)), (lightsBRadius * tableScaleX((((smallStartY1 + smallStartY2) * 0.5) + (smallThirdY * 2.5)))), new lightsA_mc());
			pathTrigger = table.addTrigger(((((-(gemCenterX) - ((gemWidth + bigBumperRad) * leftGemProp1)) * 0.5) + ((-(gemMidX) - bigBumperRad) * 0.5)) * tableScaleX(gemCenterY)), gemCenterY, (((gemWidth * (1 - leftGemProp1)) * 0.5) * tableScaleX(gemCenterY)), new MovieClip());
			FLIPPER_BASE = 15;
			FLIPPER_END = 7;
			FLIPPER_LENGTH = (holeWidth * 0.79);
			FLIPPER_ANGLE = Math.atan2((rampHeight - holeHeight), rampWidth);
			FLIPPER_SPEED = 30;
			flipper1 = table.addFlipper((-(holeWidth) * tableScaleX(((TABLE_HEIGHT - holeHeight) + FLIPPER_BASE))), ((TABLE_HEIGHT - holeHeight) + FLIPPER_BASE), FLIPPER_BASE, FLIPPER_END, FLIPPER_LENGTH, flipper1_mc, WALL_MULT, FLIPPER_SPEED);
			flipper1_mc.gotoAndStop(1);
			flipper2 = table.addFlipper((holeWidth * tableScaleX(((TABLE_HEIGHT - holeHeight) + FLIPPER_BASE))), ((TABLE_HEIGHT - holeHeight) + FLIPPER_BASE), FLIPPER_BASE, FLIPPER_END, FLIPPER_LENGTH, flipper2_mc, WALL_MULT, FLIPPER_SPEED);
			flipper2_mc.gotoAndStop(1);
			table.onHitItem = hitAmberItem;
			table.gravity = 0.33;
			table.tabEnabled = (table.tabChildren = false);
			table.paused = true;
			addTableBack();
			BALL_RADIUS = 12;
			BALL_STARTY = (TABLE_HEIGHT - (bumperRad * 2));
			BALL_STARTX = (TABLE_WIDTH1_2 - ((entranceWidth * 0.5) * tableScaleX(BALL_STARTY)));
			table.setBall(BALL_STARTX, BALL_STARTY, BALL_RADIUS, new ballClip());
			ball = table.ball;
			ball.clip.cacheAsBitmap = BITMAP_CACHING;
			table.paused = true;
			i = 0;
			while (i <= NUM_FLIPPER_FRAMES) {
				prop = (Number(i) / NUM_FLIPPER_FRAMES);
				FLIPPER1_FRAMES[i] = (FLIPPER_ANGLE + (prop * (MAX_FLIPPER_ANGLE - FLIPPER_ANGLE)));
				FLIPPER2_FRAMES[i] = ((Math.PI - FLIPPER_ANGLE) - (prop * (MAX_FLIPPER_ANGLE - FLIPPER_ANGLE)));
				i++;
			};
			table.updateFlipperAt(flipper1, FLIPPER1_FRAMES[0]);
			table.updateFlipperAt(flipper2, FLIPPER2_FRAMES[0]);
			i = 0;
			while (i < KEYBOARD_LEFT.length) {
				keyMap[KEYBOARD_LEFT.charCodeAt(i)] = flipper1;
				i++;
			};
			i = 0;
			while (i < KEYBOARD_RIGHT.length) {
				keyMap[KEYBOARD_RIGHT.charCodeAt(i)] = flipper2;
				i++;
			};
			animationContainer.addChild(animationBG);
			trace("Remove DEBUG_DRAW");
			stage.addEventListener(MouseEvent.CLICK, startAmberGame);
			txt = new TextField();
			txt.width = 50;
			txt.height = 100;
			txt.selectable = false;
			txt.textColor = 0xFF0000;
			stage.addChild(txt);
			oldTime = getTimer();
			t = 0;
			maxF = -100;
			minF = 10000;
			fList = new Array(10000);
			table = dragonAmberTable;
			ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZab0defghijklmnopqrstuvwxyz0123456789.,:;\\/-_'?!%&*+[]()=<>| \"$@€#{}ºÑñ";
			HEX_VALUES = [19463107073, 40151239028, 19462787184, 40141010226, 70188942709, 70188942688, 19462840888, 23775955219, 69865664547, 9512969032, 23893074441, 22885733187, 24046217619, 24011669505, 19463022690, 69340524630, 19463039369, 69340524833, 19454768738, 69865662870, 23765082456, 23765026646, 23765123960, 23639435639, 23762317380, 69813164167, 343050065, 389228440, 354762850, 17396323, 354849680, 8875501828, 354755878, 389228421, 5171676532, 1729589302, 22922025076, 8680464902, 286873939, 839066373, 354766982, 839144836, 372248713, 839062088, 371618598, 12886356838, 406849556, 406402066, 406868020, 404060421, 406422100, 844584821, 19599545400, 5479029072, 19451244601, 19452682288, 1937011750, 70188831280, 19450298992, 69813164146, 19461981528, 19463013122, 100, 104, 34173462, 34173472, 10579440201, 879175542, 4556626, 49, 1763729430, 19451442294, 5240025604, 394876567, 17743218707, 6174224722, 70611538, 8680464792, 17290504086, 1900250214, 10510291044, 16869376, 55924501, 624309874, 5240025906, 0, 6224433216, 19630924176, 19465131395, 19467027828, 14633439384, 1900308056, 10510299410, 1916891776, 19465933161, 19066662999];
		}
		public function hitBalloonBumper(_arg1:Object){
			toggleClip(_arg1);
		}
		public function hitBarrier(){
			reversePlay(barrier.clip);
		}
		public function resize(_arg1:Event):void{
			var _local2:Graphics;
			table.scaleX = ((stage.stageWidth / TABLE_WIDTH) * (1 - SIDE_PANEL_XSCALE));
			table.scaleY = Math.min(((stage.stageHeight / TABLE_HEIGHT) * (1 - TABLE_BACK_YSCALE)));
			table.scaleX = (table.scaleY = Math.min(table.scaleY, table.scaleX));
			tableDestX = (0.5 * (stage.stageWidth - (SIDE_PANEL_XSCALE * stage.stageWidth)));
			table.x = (tableDestX + tableOffsetX);
			tableDestY = (stage.stageHeight - (table.scaleY * TABLE_HEIGHT));
			table.y = (tableDestY + tableOffsetY);
			ball.clip.scaleY = ((1 * table.scaleX) / table.scaleY);
			_local2 = bgClip.graphics;
			_local2.clear();
			_local2.beginFill(0);
			_local2.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
			panelTop.x = (table.x - (((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE) * 0.5));
			panelTop.y = (table.y - (TABLE_BACK_YSCALE * stage.stageHeight));
			_local2 = panelTop.graphics;
			_local2.clear();
			_local2.lineStyle(1);
			_local2.drawRect(0, 0, ((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE), (stage.stageHeight * TABLE_BACK_YSCALE));
			_local2 = panelRight.graphics;
			_local2.clear();
			_local2.lineStyle(1);
			_local2.drawRect(0, 0, (SIDE_PANEL_XSCALE * stage.stageWidth), stage.stageHeight);
			panelRight.x = (stage.stageWidth - (SIDE_PANEL_XSCALE * stage.stageWidth));
			panelRight.y = 0;
		}
		public function toggleClip(_arg1:Object){
			_arg1.clip.gotoAndStop((3 - _arg1.clip.currentFrame));
		}
		public function deactivateBarrier(){
			barrier.visible = false;
			barrier.clip.visible = false;
		}
		public function hitTopBell(){
			reversePlay(topBell.clip);
		}
		public function testBottomTargets(){
			if (((((targetsB[0].visible) || (targetsB[1].visible))) || (targetsB[2].visible))){
				return;
			};
			deactivateBarrier();
		}
		public function inflating(){
			if (animationClip.currentFrame == 47){
				animationClip.belly2.visible = true;
				animationClip.belly1.visible = false;
			};
		}
		public function ballEscaped(){
			trace("FAILURE!");
			trace(table.ball.x, table.ball.y);
			trace(table.ball.vX, table.ball.vY);
			loseBall();
		}
		public function startAmberGame(_arg1:Event=null){
			trace(stage.hasEventListener(MouseEvent.CLICK));
			while (numChildren) {
				removeChildAt(0);
			};
			stage.frameRate = GAME_FPS;
			ballPoints = (inflationPoints = (tablePoints = 0));
			table = amberTable;
			table.itemBouncePeriod = 0.15;
			table.itemBounceOffset = 3;
			table.itemBounceTime = 0.2;
			table.paused = false;
			stage.addChildAt(bgClip, 0);
			stage.addChild(table);
			stage.addChild(panelRight);
			stage.addChild(panelTop);
			panelTop.visible = (panelRight.visible = false);
			trace("ADDCHILD TEXT");
			stage.addChild(txt);
			animParams.bgHeight = ANIM_BG_HEIGHT;
			animParams.hRadius = ANIM_H_RADIUS;
			animParams.vRadius = ANIM_V_RADIUS;
			animParams.hSpace = ANIM_H_SPACE;
			animParams.vSpace = ANIM_V_SPACE;
			animParams.hOffset = ANIM_H_OFFSET;
			animParams.vOffset = ANIM_V_OFFSET;
			animParams.color = ANIM_COLOR;
			animParams.bgColor = ANIM_BG_COLOR;
			animParams.bgSpeed = ANIM_BG_SPEED;
			stage.addEventListener(KeyboardEvent.KEY_DOWN, kDown);
			stage.addEventListener(KeyboardEvent.KEY_UP, kUp);
			stage.addEventListener(Event.ENTER_FRAME, eFrame, false, -10, true);
			stage.addEventListener(Event.ENTER_FRAME, initFrame, false, 10, true);
			stage.addEventListener(Event.RESIZE, resize);
			resize(null);
			resetTable();
			stage.removeEventListener(MouseEvent.CLICK, startAmberGame);
		}
		public function reversePlay(_arg1:MovieClip){
			_arg1.gotoAndStop(_arg1.totalFrames);
		}
		public function animationResize(_arg1:Event=null){
			animationContainer.y = (stage.stageHeight * 0.5);
			if (animationClip){
				animationClip.x = (stage.stageWidth * 0.5);
				animationClip.y = (animationBG.height * 0.5);
			};
			redrawAnimationBackground();
		}
		public function rotateRight(_arg1:Array){
			var _local2:int;
			var _local3:MovieClip;
			var _local4:int;
			var _local5:MovieClip;
			var _local6:int;
			_local2 = _arg1.length;
			_local4 = _arg1[(_local2 - 1)].clip.currentFrame;
			_local5 = _arg1[(_local2 - 1)].clip;
			_local6 = (_local2 - 2);
			while (_local6 >= 0) {
				_local3 = _arg1[_local6].clip;
				_local5.gotoAndStop(_local3.currentFrame);
				_local5 = _local3;
				_local6--;
			};
			_arg1[0].clip.gotoAndStop(_local4);
		}
		public function drawEllipseRow(_arg1:Graphics, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int, _arg8:int, _arg9:uint){
		}
		public function activateBouncySwitch(){
			bouncySwitch.visible = true;
			bouncySwitch.clip.visible = true;
			bouncySwitch.counter = BOUNCY_COUNTER;
		}
		public function makeStar(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:int=5, _arg6:Number=0):Array{
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Array;
			var _local11:int;
			_local7 = (Math.PI / _arg5);
			_local10 = [];
			_local11 = 0;
			while (_local11 < (_arg5 * 2)) {
				_local9 = ((_local11 % 2)) ? _arg4 : _arg3;
				_local8 = (_local11 * _local7);
				_local10[_local10.length] = {x:(_arg1 + (Math.cos(((_local8 + _arg6) - (Math.PI * 0.5))) * _local9)), y:(_arg2 + (Math.sin(((_local8 + _arg6) - (Math.PI * 0.5))) * _local9))};
				_local11++;
			};
			return (_local10);
		}
		public function disableAllCurrentHitStates(){
			var _local1:Object;
			for (_local1 in currentHitState) {
				setHitState(_local1, false);
			};
		}
		public function tableScaleX(_arg1:Number):Number{
			var _local2:Number;
			_local2 = ((TABLE_HEIGHT - _arg1) / TABLE_HEIGHT);
			return ((1 + (_local2 * ((TABLE_TOP / TABLE_WIDTH) - 1))));
		}
		public function endWarp(){
			if (externalBall.parent){
				externalBall.parent.removeChild(externalBall);
			};
			externalBall = null;
			ball.clip.visible = true;
			ball.x = (ball.clip.x = ((-(TABLE_WIDTH1_2) + (remainingWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)))));
			ball.y = (ball.clip.y = ((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)));
			ball.vY = -20;
			activateBarrier();
			activateBottomTargets();
		}
		public function startAnimationMode(_arg1:int, _arg2:MovieClip, _arg3:int=0, _arg4:Function=null, _arg5:Function=null, _arg6:Function=null){
			table.paused = true;
			table.cancel();
			if (stage.frameRate != ANIMATION_FPS){
				stage.frameRate = ANIMATION_FPS;
			};
			animationTimer = _arg3;
			animationID = _arg1;
			animationClip = _arg2;
			animStartFunc = _arg4;
			animFrameFunc = _arg5;
			animEndFunc = _arg6;
			animationResize();
			stage.addChild(animationContainer);
			animationContainer.scaleY = 0;
			if (animationClip){
				animationClip.x = (stage.stageWidth * 0.5);
				animationClip.y = (animationBG.height * 0.5);
				animationContainer.addChild(animationClip);
				animationClip.gotoAndStop(1);
			};
			animationState = AS_START;
			stage.addEventListener(Event.RESIZE, animationResize, false, 0, true);
			if (Boolean(animStartFunc)){
				animStartFunc();
			};
		}
		public function deactivateEntranceDoor(){
			entranceDoor.visible = false;
		}
		public function activateBottomTargets(){
			targetsB[0].visible = (targetsB[0].clip.visible = (targetsB[1].visible = (targetsB[1].clip.visible = (targetsB[2].visible = (targetsB[2].clip.visible = true)))));
			targetsB[0].counter = (targetsB[1].counter = (targetsB[2].counter = TARGETB_COUNTER));
			targetsB[0].clip.gotoAndStop(TARGETB_COUNTER);
			targetsB[1].clip.gotoAndStop(TARGETB_COUNTER);
			targetsB[2].clip.gotoAndStop(TARGETB_COUNTER);
		}
		public function startWarp(){
			var _local1:Point;
			activateBouncySwitch();
			caveLight.clip.gotoAndStop(2);
			ball.clip.visible = false;
			externalBall = new ballClip();
			_local1 = warpEntrance.clip.localToGlobal(new Point());
			externalBall.x = _local1.x;
			externalBall.y = _local1.y;
			externalBall.scaleX = (externalBall.scaleY = table.scaleX);
			externalBall.visible = false;
			stage.addChild(externalBall);
			animationClip.x = (stage.stageWidth - animationClip.getBounds(animationClip).left);
			animationClip.ball.visible = false;
		}
		public function addTableBack(){
			table.back.addChild(new tableBack());
			table.back.getChildAt((table.back.numChildren - 1)).cacheAsBitmap = BITMAP_CACHING;
		}
		public function initFrame(_arg1:Event){
			launcherHit = false;
			itemsHit.length = 0;
		}
		public function stopAnimationMode(){
			table.paused = false;
			if (stage.frameRate != GAME_FPS){
				stage.frameRate = GAME_FPS;
			};
			if (animationContainer.parent){
				animationContainer.parent.removeChild(animationContainer);
			};
			if (animationClip){
				if (animationClip.parent){
					animationClip.parent.removeChild(animationClip);
				};
				animationClip = null;
			};
			if (Boolean(animEndFunc)){
				animEndFunc();
			};
			clearAnimationBackground();
			stage.removeEventListener(Event.RESIZE, animationResize);
			animationID = NO_ANIM;
			animStartFunc = null;
			animFrameFunc = null;
			animEndFunc = null;
		}
		public function drawMovingBG(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int, _arg8:int, _arg9:uint, _arg10:uint):BitmapData{
			var _local11:int;
			var _local12:int;
			var _local13:int;
			var _local14:int;
			var _local15:int;
			var _local16:int;
			var _local17:int;
			var _local18:Shape;
			var _local19:Graphics;
			var _local20:BitmapData;
			_local17 = _arg7;
			_local18 = new Shape();
			_local19 = _local18.graphics;
			_local19.drawRect(0, 0, _arg1, _arg2);
			_local15 = _arg8;
			while (_local15 > -(_arg4)) {
				_local15 = (_local15 - _arg6);
			};
			_local16 = (_arg2 + _arg8);
			while (_local16 < (_arg2 + _arg4)) {
				_local16 = (_local16 + _arg6);
			};
			_local14 = _local15;
			while (_local14 < _local16) {
				_local12 = _local17;
				while (_local12 > -(_arg3)) {
					_local12 = (_local12 - _arg5);
				};
				_local13 = (_arg1 + _local17);
				while (_local13 < (_arg1 + _arg3)) {
					_local13 = (_local13 + _arg5);
				};
				_local11 = _local12;
				while (_local11 <= _local13) {
					_local19.beginFill(_arg9);
					_local19.drawEllipse((_local11 - _arg3), (_local14 - _arg4), (_arg3 << 1), (_arg4 << 1));
					_local19.endFill();
					_local11 = (_local11 + _arg5);
				};
				_local14 = (_local14 + _arg6);
				_local17 = (_local17 + _arg7);
			};
			_local20 = new BitmapData(_arg1, _arg2, false, _arg10);
			_local20.draw(_local18);
			_local19.clear();
			_local20.fillRect(new Rectangle(0, 0, _arg1, 8), _arg9);
			_local20.fillRect(new Rectangle(0, (_arg2 - 8), _arg1, 8), _arg9);
			return (_local20);
		}
		public function endInflation(){
			ball.clip.visible = true;
			ball.x = ((gemMidX - ball.radius) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5))));
			ball.y = (2 * bumperRad);
			ball.vX = (-12 + Math.floor(((Math.random() * 6) - 3)));
			ball.vY = (-5 + Math.floor((Math.random() * 3)));
			table.cancel();
		}
		public function rUp(_arg1:Event){
			stage.removeEventListener(MouseEvent.MOUSE_MOVE, rMove);
			stage.removeEventListener(MouseEvent.MOUSE_UP, rUp);
		}
		public function hitLightsA(_arg1:Object){
			toggleClip(_arg1);
		}
		public function hitLightsB(_arg1:Object){
			toggleClip(_arg1);
		}
		public function loseBall(){
			if (goldApples < EXTRA_BALL_APPLES){
				resetTable();
			} else {
				goldApples = 0;
				startAnimationMode(SAVE_BALL_ANIM, new AmberCatchClip(), 0, null, null, ballSaved);
			};
		}
		public function draw5x6Hex(_arg1:Graphics, _arg2:uint, _arg3:Number=1, _arg4:Number=1, _arg5:Number=1, _arg6:Number=1, _arg7:Number=1, _arg8:Number=1){
			var _local9:int;
			var _local10:int;
			var _local11:int;
			var _local12:int;
			_local9 = 0;
			while (_local9 < 32) {
				if (!(_arg2 & (1 << _local9))){
				} else {
					_local10 = ((31 - _local9) - 2);
					_local11 = (_local10 % 5);
					_local12 = (_local10 / 5);
					_arg1.drawRect((_arg3 + (_local11 * (_arg5 + _arg7))), (_arg4 + (_local12 * (_arg6 + _arg8))), _arg5, _arg6);
				};
				_local9++;
			};
		}
		public function startInflation(){
			ball.clip.visible = false;
			inflateLight.clip.gotoAndStop(1);
			caveLight.clip.gotoAndStop(1);
			animationClip.belly1.visible = true;
			animationClip.belly2.visible = false;
			animationClip.belly1.gotoAndStop(1);
			animationClip.belly2.gotoAndStop(1);
			inflationPoints = (inflationPoints + ballPoints);
			ballPoints = 0;
		}
		public function hitBell(){
			reversePlay(bell.clip);
		}
		public function activateBarrier(){
			barrier.visible = true;
			barrier.clip.visible = true;
		}
		public function activateTopTargets(){
			targetsA[0].visible = (targetsA[0].clip.visible = (targetsA[1].visible = (targetsA[1].clip.visible = (targetsA[2].visible = (targetsA[2].clip.visible = true)))));
		}
		public function setHitState(_arg1:Object, _arg2:Boolean=true){
			if (currentHitState[_arg1]){
				previousHitState[_arg1] = currentHitState[_arg1];
			} else {
				previousHitState[_arg1] = false;
			};
			currentHitState[_arg1] = _arg2;
		}
		public function rMove(_arg1:Event){
			var _local2:Number;
			_local2 = Math.floor(((stage.mouseX - oldMX) * 0.5));
			reshiram.belly.gotoAndStop(Math.max(1, Math.min((oldFrame + _local2), reshiram.belly.totalFrames)));
		}
		public function endGame(_arg1:Event=null){
			table.paused = true;
			table.parent.removeChild(table);
			stage.removeEventListener(KeyboardEvent.KEY_DOWN, kDown);
			stage.removeEventListener(KeyboardEvent.KEY_UP, kUp);
			stage.removeEventListener(Event.ENTER_FRAME, eFrame);
			stage.removeEventListener(Event.ENTER_FRAME, initFrame);
			stage.removeEventListener(Event.RESIZE, resize);
		}
		public function rotateAllRight(){
			rotateRight(lightsA);
			rotateRight(lightsB);
			rotateRight(centerBumpers);
			rotateRight(balloonBumpers);
		}
		public function animating(_arg1:Event=null){
			if (animationState == AS_START){
				animationContainer.scaleY = (animationContainer.scaleY + ((1 - animationContainer.scaleY) * 0.4));
				if (animationContainer.scaleY >= 0.99){
					animationContainer.scaleY = 1;
					animationState = AS_PLAY;
				};
			} else {
				if (animationState == AS_PLAY){
					if (!animationClip){
						if (animationTimer <= 0){
							animationState = AS_END;
						};
					} else {
						if (animationClip.currentFrame == animationClip.totalFrames){
							if (animationTimer <= 0){
								animationState = AS_END;
							};
						} else {
							animationClip.nextFrame();
						};
					};
					animationTimer--;
				} else {
					if (animationState == AS_END){
						animationContainer.scaleY = (animationContainer.scaleY * 0.5);
						if (animationContainer.scaleY <= 0.05){
							animationContainer.scaleY = 0;
							stopAnimationMode();
							return;
						};
					};
				};
			};
			animationBmp1.x = (animationBmp1.x - ANIM_BG_SPEED);
			animationBmp2.x = (animationBmp2.x - ANIM_BG_SPEED);
			if (animationBmp1.x < -(animationBmp1.width)){
				animationBmp1.x = (animationBmp2.x + animationBmp2.width);
			};
			if (animationBmp2.x < -(animationBmp2.width)){
				animationBmp2.x = (animationBmp1.x + animationBmp1.width);
			};
			if (Boolean(animFrameFunc)){
				animFrameFunc();
			};
		}
		public function rotateAllLeft(){
			rotateLeft(lightsA);
			rotateLeft(lightsB);
			rotateLeft(centerBumpers);
			rotateLeft(balloonBumpers);
		}
		public function deactivateBouncySwitch(){
			bouncySwitch.visible = false;
			bouncySwitch.clip.visible = false;
		}
		public function kDown(_arg1:KeyboardEvent){
			var _local2:int;
			var _local3:int;
			_local2 = _arg1.keyCode;
			if (keysDown[_local2]){
				return;
			};
			keysDown[_local2] = true;
			if (!isNaN(keyMap[_local2])){
				_local3 = keyMap[_local2];
				if (_local3 == flipper1){
					leftKeys++;
				} else {
					if (_local3 == flipper2){
						rightKeys++;
					};
				};
			};
			switch (_local2){
				case Keyboard.TAB:
					if (table.paused){
						break;
					};
					tableOffsetX = 5;
					table.x = (tableDestX + tableOffsetX);
					panelTop.x = (table.x - (((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE) * 0.5));
					ball.vX = (ball.vX + 4);
					ball.vY = (ball.vY + 1);
					break;
				case Keyboard.BACKSPACE:
					if (table.paused){
						break;
					};
					tableOffsetX = -5;
					table.x = (tableDestX + tableOffsetX);
					panelTop.x = (table.x - (((table.scaleX * TABLE_WIDTH) * TABLE_TOP_XSCALE) * 0.5));
					ball.vX = (ball.vX - 4);
					ball.vY = (ball.vY + 1);
					break;
				case Keyboard.ENTER:
					if (((!(animationID)) && (!(keysDown[Keyboard.SPACE])))){
						table.paused = !(table.paused);
						if (table.paused){
							stage.addChild(pauseClip);
						} else {
							stage.removeChild(pauseClip);
						};
					};
					break;
			};
		}
		public function ballSaved(){
			ball.x = BALL_STARTX;
			ball.y = BALL_STARTY;
			ball.vX = (ball.vY = 0);
		}
		public function warpFrame(){
			var _local1:Point;
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:int;
			animationClip.x = (animationClip.x + (((stage.stageWidth * 0.5) - animationClip.x) * 0.2));
			if (animationState == AS_START){
				return;
			};
			externalBall.visible = true;
			_local5 = 50;
			if (animationClip.currentFrame < 5){
				_local1 = animationClip.ball.localToGlobal(new Point());
				_local2 = (_local1.x - externalBall.x);
				_local3 = (_local1.y - externalBall.y);
				_local4 = Math.sqrt(((_local2 * _local2) + (_local3 * _local3)));
				if (_local4 > _local5){
					animationClip.prevFrame();
					externalBall.x = (externalBall.x + (_local5 * (_local2 / _local4)));
					externalBall.y = (externalBall.y + (_local5 * (_local3 / _local4)));
				} else {
					externalBall.x = _local1.x;
					externalBall.y = _local1.y;
				};
			} else {
				if (animationClip.currentFrame <= 42){
					_local1 = animationClip.ball.localToGlobal(new Point());
					_local2 = (_local1.x - externalBall.x);
					_local3 = (_local1.y - externalBall.y);
					_local4 = Math.sqrt(((_local2 * _local2) + (_local3 * _local3)));
					externalBall.x = _local1.x;
					externalBall.y = _local1.y;
				} else {
					_local1 = table.localToGlobal(new Point(((-(TABLE_WIDTH1_2) + (remainingWidth * 0.5)) * tableScaleX(((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5)))), ((TABLE_HEIGHT - sideHeight) - (remainingWidth * 0.5))));
					_local2 = (_local1.x - externalBall.x);
					_local3 = (_local1.y - externalBall.y);
					_local4 = Math.sqrt(((_local2 * _local2) + (_local3 * _local3)));
					if (_local4 > _local5){
						if (animationClip.currentFrame == (animationClip.totalFrames - 1)){
							animationClip.prevFrame();
						};
						externalBall.x = (externalBall.x + (_local5 * (_local2 / _local4)));
						externalBall.y = (externalBall.y + (_local5 * (_local3 / _local4)));
					} else {
						externalBall.x = _local1.x;
						externalBall.y = _local1.y;
					};
				};
			};
		}
		public function resetTable(){
			ball.x = BALL_STARTX;
			ball.y = BALL_STARTY;
			ball.vX = (ball.vY = 0);
			goldApples = 0;
			ballPoints = 0;
			deactivateEntranceDoor();
			deactivateBouncySwitch();
			activateTopTargets();
			activateBottomTargets();
			activateBarrier();
			caveLight.clip.gotoAndStop(1);
			inflateLight.clip.gotoAndStop(1);
			lightsA[0].clip.gotoAndStop(1);
			lightsA[1].clip.gotoAndStop(1);
			lightsA[2].clip.gotoAndStop(1);
			lightsA[3].clip.gotoAndStop(1);
			lightsB[0].clip.gotoAndStop(1);
			lightsB[1].clip.gotoAndStop(1);
			lightsB[2].clip.gotoAndStop(1);
			centerBumpers[0].clip.gotoAndStop(1);
			centerBumpers[1].clip.gotoAndStop(1);
			centerBumpers[2].clip.gotoAndStop(1);
			balloonBumpers[0].clip.gotoAndStop(1);
			balloonBumpers[1].clip.gotoAndStop(1);
			balloonBumpers[2].clip.gotoAndStop(1);
			table.cancel();
		}

	}
}//package game_fla 
Section 4
//Table (pinball.Table)
package pinball {
	import flash.events.*;
	import flash.display.*;

	public final class Table extends MovieClip {

		private var _flippers:Array;
		var _bounceDecay:Number;
		public var onHitItem:Function;
		private var _itemBounceOffset:Number;
		private var _maxSpeed:Number;
		private var _items:Array;
		private var _table:MovieClip;
		private var _ball:Object;
		private var _itemBounceTime:Number;
		private var _triggers:Array;
		private var _gravity:Number;
		private var _front:MovieClip;
		public var paused:Boolean;
		private var _ballClip:MovieClip;
		private var _triggerClip:MovieClip;
		var _bounceFrequency:Number;
		private var _itemBouncePeriod:Number;
		private var _cancel:Boolean;
		private var _back:MovieClip;

		public static const WALL:int = 1;
		public static const TRIGGER:int = 5;
		public static const POLYGON:int = 2;
		public static const BUMPER:int = 0;
		public static const FLIPPER:int = 3;
		public static const BALL:int = 4;

		private static var DIRECTIONS:Array = [[0, 6], [8, 0], [0, -10], [-7, 0], [-5, -7], [10, -6]];

		public function Table(){
			paused = false;
			onHitItem = null;
			_ball = {visible:true, type:BALL, x:0, y:0, vX:0, vY:0, remaining:0, clip:null};
			_gravity = 1;
			_cancel = false;
			_maxSpeed = 30;
			_itemBounceOffset = 2;
			_itemBounceTime = 1.6;
			_itemBouncePeriod = 0.6;
			_bounceDecay = 0;
			_bounceFrequency = 0;
			_back = new MovieClip();
			_triggerClip = new MovieClip();
			_ballClip = new MovieClip();
			_table = new MovieClip();
			_front = new MovieClip();
			this.addChild(_back);
			this.addChild(_triggerClip);
			this.addChild(_ballClip);
			this.addChild(_table);
			this.addChild(_front);
			_items = [];
			_triggers = [];
			_flippers = [];
			addEventListener(Event.ADDED_TO_STAGE, added);
			removeEventListener(Event.REMOVED_FROM_STAGE, removed);
		}
		public function DEBUG_DRAW_FLIPPER(_arg1:Graphics, _arg2:Object){
			_arg1.drawEllipse((_arg2.x - _arg2.maxRadius), (_arg2.y - _arg2.maxRadius), (_arg2.maxRadius * 2), (_arg2.maxRadius * 2));
			DEBUG_DRAW_POLYGON(_arg1, _arg2);
		}
		public function addWall(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:MovieClip, _arg7:Number):Object{
			var _local8:Object;
			_local8 = {visible:true, type:WALL, x0:_arg1, y0:_arg2, x1:_arg3, y1:_arg4, thickness:_arg5, clip:_arg6, bounce:false, offset:0, direction:0, wave:0, multiplier:_arg7};
			if (_arg4 > _arg2){
				_local8.x = _arg3;
				_local8.y = _arg4;
			} else {
				_local8.x = _arg1;
				_local8.y = _arg2;
			};
			_local8.minY = Math.min(_arg2, _arg4);
			_arg6.x = _local8.x;
			_arg6.y = _local8.y;
			insertItemOrdered(_local8);
			return (_local8);
		}
		public function get front():MovieClip{
			return (_front);
		}
		public function set itemBouncePeriod(_arg1:Number){
			_itemBouncePeriod = _arg1;
		}
		public function get gravity():Number{
			return (_gravity);
		}
		private function removed(_arg1:Event){
			stage.removeEventListener("enterFrame", update);
		}
		public function addBumper(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:MovieClip, _arg5:Number):Object{
			var _local6:Object;
			_local6 = {visible:true, type:BUMPER, x:_arg1, y:_arg2, radius:_arg3, clip:_arg4, bounce:false, offset:0, direction:0, wave:0, multiplier:_arg5};
			_local6.minY = _arg2;
			_arg4.x = _arg1;
			_arg4.y = _arg2;
			insertItemOrdered(_local6);
			return (_local6);
		}
		public function set maxSpeed(_arg1:Number){
			if (_arg1 < 0){
				_arg1 = 0;
			};
			_maxSpeed = _arg1;
		}
		private function removeTrigger(_arg1:Object){
			var _local2:int;
			_local2 = 0;
			while (_local2 < _triggers.length) {
				if (_triggers[_local2] == _arg1){
					_arg1.clip.parent.removeChild(_arg1.clip);
					_triggers.splice(_local2, 1);
					return;
				};
				_local2++;
			};
		}
		public function removeBall(){
			removeItem(_ball);
			_ball.clip = null;
			_ball.x = 0;
			_ball.y = 0;
			_ball.minY = _ball.y;
			_ball.vX = 0;
			_ball.vY = 0;
		}
		public function cancel():void{
			_cancel = true;
		}
		public function set gravity(_arg1:Number){
			_gravity = _arg1;
		}
		public function update(_arg1:Event):void{
			var _local2:int;
			var _local3:int;
			var _local4:Object;
			var _local5:MovieClip;
			var _local6:Number;
			var _local7:int;
			var _local8:int;
			var _local9:Array;
			var _local10:Array;
			var _local11:Boolean;
			var _local12:Boolean;
			var _local13:Number;
			var _local14:Number;
			var _local15:Object;
			var _local16:Object;
			var _local17:Object;
			var _local18:Number;
			var _local19:Number;
			var _local20:Number;
			var _local21:Number;
			var _local22:Number;
			var _local23:Number;
			var _local24:Number;
			var _local25:Number;
			var _local26:Object;
			var _local27:Object;
			var _local28:Object;
			var _local29:Number;
			var _local30:Number;
			_local3 = _items.length;
			_bounceDecay = ((1 / _itemBounceTime) / stage.frameRate);
			_bounceFrequency = (((Math.PI * 2) / _itemBouncePeriod) / stage.frameRate);
			_local2 = 0;
			for (;_local2 < _local3;_local2++) {
				_local4 = _items[_local2];
				if (!((_local4.bounce) && ((_local4.offset > 0)))){
				} else {
					_local5 = _local4.clip;
					_local6 = Math.sin(_local4.wave);
					_local5.x = (_local4.x + ((_local4.xMul * _local6) * _local4.offset));
					_local5.y = (_local4.y + ((_local4.yMul * _local6) * _local4.offset));
					_local4.wave = (_local4.wave + _bounceFrequency);
					_local4.time = (_local4.time - _bounceDecay);
					_local4.offset = (_local4.time * _itemBounceOffset);
					if (_local4.offset <= 0){
						_local4.offset = 0;
						_local5.x = _local4.x;
						_local5.y = _local4.y;
						continue;
					};
				};
			};
			if (((paused) || (!(_ball.clip)))){
				return;
			};
			_cancel = false;
			_local13 = 1;
			_ball.remaining = 1;
			_local11 = true;
			_local7 = 50;
			while (((((((_local12) || (_local11))) && ((_local7 > 0)))) && (_ball.visible))) {
				_local22 = Math.sqrt(((ball.vX * ball.vX) + (ball.vY * ball.vY)));
				_local23 = (1 / _local22);
				_local7--;
				_local9 = [];
				_local12 = false;
				_local11 = false;
				_local2 = 0;
				while (_local2 < _local3) {
					_local4 = _items[_local2];
					if (_local4 == _ball){
					} else {
						if (!_local4.visible){
						} else {
							switch (_local4.type){
								case WALL:
									_local10 = ballHitWall(_ball, _local4, _local13);
									break;
								case POLYGON:
									_local10 = ballHitPolygon(_ball, _local4, _local13);
									break;
								case BUMPER:
									_local10 = ballHitCircle(_ball, _local4, (_local13 + _local23));
									break;
								case FLIPPER:
									_local10 = newBallHitFlipper(_ball, _local4, _local13);
									break;
								default:
									_local10 = [];
									break;
							};
							if (!_local10.length){
							} else {
								_local9 = _local9.concat(_local10);
							};
						};
					};
					_local2++;
				};
				if (_ball.remaining < _local23){
					_local10 = checkForTriggers(_local13);
					if (((!(_ball.visible)) || (_cancel))){
						return;
					};
					_ball.remaining = 0;
					break;
				};
				_local8 = _local9.length;
				if (!_local8){
					_local10 = checkForTriggers(_local13);
					if (((!(_ball.visible)) || (_cancel))){
						return;
					};
					break;
				};
				_local2 = 0;
				while (_local2 < _local8) {
					_local14 = moveBallToLine(ball, _local9[_local2]);
					if ((((_local14 >= 0)) && ((_local14 < _local13)))){
						_local13 = _local14;
						_local12 = true;
					};
					_local2++;
				};
				if (_local12){
					_local10 = checkForTriggers(_local13);
					if (((!(_ball.visible)) || (_cancel))){
						return;
					};
				} else {
					_local21 = Infinity;
					_local16 = null;
					_local10.length = 1;
					if (_local8 > 1){
						_local2 = 0;
						while (_local2 < _local8) {
							_local17 = _local9[_local2];
							_local10[0] = intersectLines(_ball.x, _ball.y, (_ball.x + (_ball.vX * (1 + (_ball.radius * _local23)))), (_ball.y + (_ball.vY * (1 + (_ball.radius * _local23)))), _local17.x0, _local17.y0, _local17.x1, _local17.y1);
							if (((_local10[0]) && (pointInsideRect(_local10[0].x, _local10[0].y, _local17.x0, _local17.y0, _local17.x1, _local17.y1)))){
								_local18 = (_local10[0].x - _ball.x);
								_local19 = (_local10[0].y - _ball.y);
								_local20 = ((_local18 * _local18) + (_local19 * _local19));
								if (_local20 < _local21){
									_local21 = _local20;
									_local16 = _local17;
								};
							};
							_local2++;
						};
						if (!_local16){
							_local16 = _local9[0];
						};
					} else {
						_local16 = _local9[0];
					};
					_local10 = checkForTriggers(_local13);
					if (((!(_ball.visible)) || (_cancel))){
						return;
					};
					_local24 = Math.max((_local13 - _local23), 0);
					_ball.x = (_ball.x + (_ball.vX * Math.min(_local24, _ball.remaining)));
					_ball.y = (_ball.y + (_ball.vY * Math.min(_local24, _ball.remaining)));
					_ball.remaining = Math.max((_ball.remaining - _local24), 0);
					_local15 = reflect(_ball.vX, _ball.vY, _local16.x0, _local16.y0, _local16.x1, _local16.y1);
					if (((isNaN(_local15.vX)) || (isNaN(_local15.vY)))){
						trace("REFLECT!", _ball.vX, _ball.vY, _local16.x0, _local16.y0, _local16.x1, _local16.y1, _local16.item.type);
					};
					_local25 = Math.atan2((_local16.y1 - _local16.y0), (_local16.x1 - _local16.x0));
					_local26 = rotate(_local15.vX, _local15.vY, -(_local25));
					if ((((_local16.item.type == FLIPPER)) && (_local16.item.updated))){
						_local27 = _local16.item;
						_local28 = projectPointOnLine(ball.x, ball.y, _local27.x, _local27.y, (_local27.x + Math.cos(_local27.angle)), (_local27.y + Math.sin(_local27.angle)));
						_local18 = (_local28.x - _local27.x);
						_local19 = (_local28.y - _local27.y);
						_local20 = Math.sqrt(((_local18 * _local18) + (_local19 * _local19)));
						_local29 = Math.min((_local20 / _local27.length), 1);
						_local30 = (_local29 * _local27.minSpeed);
						_local30 = Math.max(_local22, _local30);
						_local26.x = (_local26.x * (_local30 / _local22));
						_local26.y = (_local26.y * (_local30 / _local22));
						if (_local26.y > -(_local30)){
							_local26.y = -(_local30);
						};
					} else {
						_local26.y = (_local26.y * _local16.item.multiplier);
					};
					_local26 = rotate(_local26.x, _local26.y, _local25);
					hitItem(_local16.item, _local16);
					if (Boolean(onHitItem)){
						onHitItem(_ball.x, _ball.y, _local16, _local16.item);
						if (((!(_ball.visible)) || (_cancel))){
							return;
						};
					};
					_ball.vX = _local26.x;
					_ball.vY = _local26.y;
					_local22 = Math.sqrt(((_ball.vX * _ball.vX) + (_ball.vY * _ball.vY)));
					if (_local22 > maxSpeed){
						_ball.vX = (_ball.vX * (maxSpeed / _local22));
						_ball.vY = (_ball.vY * (maxSpeed / _local22));
						_local22 = maxSpeed;
						_local23 = (1 / _local22);
					};
					if (_ball.remaining > 0){
						_local13 = _ball.remaining;
						_local11 = true;
					};
				};
			};
			_ball.x = (_ball.x + (_ball.vX * _ball.remaining));
			_ball.y = (_ball.y + (_ball.vY * _ball.remaining));
			_ball.clip.x = _ball.x;
			_ball.clip.y = _ball.y;
			_ball.vY = (_ball.vY + _gravity);
			_local3 = _flippers.length;
			_local2 = 0;
			while (_local2 < _local3) {
				_flippers[_local2].updated = false;
				_local2++;
			};
		}
		public function DEBUG_DRAW_WALL(_arg1:Graphics, _arg2:Object){
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Object;
			var _local9:Object;
			var _local10:Array;
			_local3 = Math.atan2((_arg2.y1 - _arg2.y0), (_arg2.x1 - _arg2.x0));
			_local4 = (Math.cos(_local3) * _arg2.thickness);
			_local5 = (Math.sin(_local3) * _arg2.thickness);
			_local6 = _local5;
			_local7 = -(_local4);
			_local8 = {x:(_arg2.x0 - _local4), y:(_arg2.y0 - _local5)};
			_local9 = {x:(_arg2.x1 + _local4), y:(_arg2.y1 + _local5)};
			_local10 = [{x:(_local8.x + _local6), y:(_local8.y + _local7)}, {x:(_local9.x + _local6), y:(_local9.y + _local7)}, {x:(_local9.x - _local6), y:(_local9.y - _local7)}, {x:(_local8.x - _local6), y:(_local8.y - _local7)}];
			DEBUG_DRAW_POLYGON(_arg1, {poly:_local10});
		}
		public function get back():MovieClip{
			return (_back);
		}
		public function get itemBounceTime():Number{
			return (_itemBounceTime);
		}
		private function reorder(){
			var _local1:int;
			var _local2:int;
			var _local3:Object;
			_local1 = 0;
			while (_local1 < (_items.length - 1)) {
				_local2 = (_local1 + 1);
				while (_local2 < _items.length) {
					if (_items[_local1].y > _items[_local2].y){
						_local3 = _items[_local1];
						_items[_local1] = _items[_local2];
						_items[_local2] = _local3;
					};
					_local2++;
				};
				_local1++;
			};
			_local1 = 0;
			while (_local1 < _items.length) {
				_table.addChildAt(_items[_local1].clip, _local1);
				_local1++;
			};
		}
		private function added(_arg1:Event){
			stage.addEventListener("enterFrame", update, false, 0, true);
			_bounceDecay = (_itemBounceTime / stage.frameRate);
			_bounceFrequency = (((Math.PI * 2) / stage.frameRate) / _itemBouncePeriod);
		}
		public function DEBUG_DRAW_BALL(_arg1:Graphics, _arg2:Object){
			var _local3:Number;
			var _local4:Number;
			var _local5:Object;
			_arg1.drawCircle(_arg2.x, _arg2.y, _arg2.radius);
			if ((((Math.abs(_arg2.vX) < 0.001)) && ((Math.abs(_arg2.vY) < 0.001)))){
				return;
			};
			_arg1.drawCircle((_arg2.x + (_arg2.vX * _arg2.remaining)), (_arg2.y + (_arg2.vY * _arg2.remaining)), _arg2.radius);
			_local3 = Math.sqrt(((_arg2.vX * _arg2.vX) + (_arg2.vY * _arg2.vY)));
			_local4 = (1 / _local3);
			_local5 = {x:(_arg2.vY * _local4), y:(-(_arg2.vX) * _local4)};
			_arg1.moveTo((_arg2.x + (_arg2.radius * _local5.x)), (_arg2.y + (_arg2.radius * _local5.y)));
			_arg1.lineTo(((_arg2.x + (_arg2.vX * _arg2.remaining)) + (_arg2.radius * _local5.x)), ((_arg2.y + (_arg2.vY * _arg2.remaining)) + (_arg2.radius * _local5.y)));
			_arg1.moveTo((_arg2.x - (_arg2.radius * _local5.x)), (_arg2.y - (_arg2.radius * _local5.y)));
			_arg1.lineTo(((_arg2.x + (_arg2.vX * _arg2.remaining)) - (_arg2.radius * _local5.x)), ((_arg2.y + (_arg2.vY * _arg2.remaining)) - (_arg2.radius * _local5.y)));
		}
		public function get itemBouncePeriod():Number{
			return (_itemBouncePeriod);
		}
		public function updateFlipperAt(_arg1:int, _arg2:Number):void{
			var _local3:Object;
			var _local4:Array;
			var _local5:Array;
			var _local6:Object;
			var _local7:Object;
			var _local8:Object;
			if ((((_arg1 >= _flippers.length)) || ((_arg1 < 0)))){
				return;
			};
			_local3 = _flippers[_arg1];
			_local4 = _local3.local;
			_local5 = _local3.poly;
			_local3.oldAngle = _local3.angle;
			_local3.angle = _arg2;
			_local3.updated = true;
			_arg1 = 0;
			while (_arg1 < 4) {
				_local6 = _local4[_arg1];
				_local8 = _local5[_arg1];
				_local7 = rotate(_local6.x, _local6.y, _arg2);
				_local8.x = (_local7.x + _local3.x);
				_local8.y = (_local7.y + _local3.y);
				_arg1++;
			};
		}
		public function get maxSpeed():Number{
			return (_maxSpeed);
		}
		private function hitItem(_arg1:Object, _arg2:Object){
			var _local3:Object;
			_local3 = {x:(_arg2.y1 - _arg2.y0), y:(_arg2.x0 - _arg2.x1)};
			_arg1.offset = _itemBounceOffset;
			_arg1.direction = Math.atan2(-(_local3.y), -(_local3.x));
			_arg1.xMul = Math.cos(_arg1.direction);
			_arg1.yMul = Math.sin(_arg1.direction);
			_arg1.wave = 0;
			_arg1.time = 1;
		}
		private function insertItemOrdered(_arg1:Object):void{
			var _local2:int;
			if (!(_arg1.clip as MovieClip)){
				return;
			};
			_local2 = 0;
			while (_local2 < _items.length) {
				if (_items[_local2].y >= _arg1.y){
					_items.splice(_local2, 0, _arg1);
					_table.addChildAt(_arg1.clip, _local2);
					_arg1.clip.gotoAndStop(1);
					return;
				};
				_local2++;
			};
			_items.push(_arg1);
			_table.addChild(_arg1.clip);
			_arg1.clip.gotoAndStop(1);
		}
		public function addPolygon(_arg1:Array, _arg2:MovieClip, _arg3:Number):Object{
			var _local4:Object;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:int;
			var _local9:int;
			_local4 = {visible:true, type:POLYGON, poly:[], clip:_arg2, bounce:false, offset:0, direction:0, wave:0, multiplier:_arg3};
			_local5 = -(Infinity);
			_local6 = -(Infinity);
			_local7 = -(Infinity);
			_local9 = _arg1.length;
			if (!_local9){
				throw ("Error: The list has no elements1");
			};
			_local8 = 0;
			while (_local8 < _local9) {
				if (((((!(_arg1[_local8])) || (isNaN(_arg1[_local8].x)))) || (isNaN(_arg1[_local8].y)))){
					throw ((((((("Error: One of the elements of the array ([" + _local8) + "]={x:") + _arg1[_local8].x) + ",y:") + _arg1[_local8].y) + "}) is not a point."));
				};
				if (_arg1[_local8].y > _local6){
					_local5 = _arg1[_local8].x;
					_local6 = _arg1[_local8].y;
				};
				if (_arg1[_local8].y < _local7){
					_local7 = _arg1[_local8].y;
				};
				_local4.poly[_local4.poly.length] = {x:_arg1[_local8].x, y:_arg1[_local8].y};
				_local8++;
			};
			_local4.minY = _local7;
			_local4.x = _local5;
			_local4.y = _local6;
			_arg2.x = _local4.x;
			_arg2.y = _local4.y;
			insertItemOrdered(_local4);
			return (_local4);
		}
		private function checkForTriggers(_arg1){
			var _local2:Object;
			var _local3:Array;
			var _local4:int;
			var _local5:int;
			_local5 = _triggers.length;
			_local4 = 0;
			while (_local4 < _local5) {
				_local2 = _triggers[_local4];
				_local3 = ballHitCircle(_ball, _local2, _arg1);
				if (((_local3.length) && (Boolean(onHitItem)))){
					onHitItem(_ball.x, _ball.y, (_local3[0] as Object), _local2);
					if (((!(_ball.visible)) || (_cancel))){
						return;
					};
				};
				_local4++;
			};
		}
		public function setBall(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:MovieClip):void{
			removeItem(_ball);
			_ball.clip = _arg4;
			_ball.x = (_arg4.x = _arg1);
			_ball.y = (_arg4.y = _arg2);
			_ball.minY = _ball.y;
			_ball.radius = _arg3;
			_ballClip.addChild(_ball.clip);
		}
		public function addFlipper(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:MovieClip, _arg7:Number, _arg8:Number):int{
			var _local9:Object;
			var _local10:int;
			var _local11:Array;
			var _local12:Array;
			_local9 = {visible:true, type:FLIPPER, x:_arg1, y:_arg2, maxRadius:_arg3, minRadius:_arg4, length:_arg5, local:[], poly:[], clip:_arg6, angle:0, oldAngle:0, multiplier:_arg7, minSpeed:_arg8, updated:false};
			_local11 = _local9.local;
			_local12 = _local9.poly;
			_local11[0] = {x:0, y:-(_arg3)};
			_local11[1] = {x:_arg5, y:-(_arg4)};
			_local11[2] = {x:_arg5, y:_arg4};
			_local11[3] = {x:0, y:_arg3};
			_local10 = 0;
			while (_local10 < 4) {
				_local12[_local10] = {x:(_local11[_local10].x + _arg1), y:(_local11[_local10].y + _arg2)};
				_local10++;
			};
			_arg6.x = _local9.x;
			_arg6.y = _local9.y;
			_flippers[_flippers.length] = _local9;
			insertItemOrdered(_local9);
			_local9.minY = _local9.y;
			return ((_flippers.length - 1));
		}
		public function DEBUG_DRAW_POLYGON(_arg1:Graphics, _arg2:Object){
			var _local3:int;
			var _local4:Array;
			var _local5:int;
			_local4 = _arg2.poly;
			_local5 = _local4.length;
			if (_local4.length < 1){
				return;
			};
			_arg1.moveTo(_local4[(_local5 - 1)].x, _local4[(_local5 - 1)].y);
			_local3 = 0;
			while (_local3 < _local5) {
				_arg1.lineTo(_local4[_local3].x, _local4[_local3].y);
				_local3++;
			};
		}
		private function removeItem(_arg1:Object):void{
			var _local2:int;
			if (_arg1.type == TRIGGER){
				removeTrigger(_arg1);
				return;
			};
			_local2 = 0;
			while (_local2 < _items.length) {
				if (_items[_local2] == _arg1){
					_arg1.clip.parent.removeChild(_arg1.clip);
					_items.splice(_local2, 1);
					return;
				};
				_local2++;
			};
		}
		public function DEBUG_DRAW_BUMPER(_arg1:Graphics, _arg2:Object){
			_arg1.drawEllipse((_arg2.x - _arg2.radius), (_arg2.y - _arg2.radius), (_arg2.radius * 2), (_arg2.radius * 2));
		}
		public function DEBUG_DRAW(_arg1:Graphics){
			var _local2:int;
			var _local3:Object;
			var _local4:int;
			_local4 = _items.length;
			_arg1.clear();
			_arg1.lineStyle(1);
			_local2 = 0;
			while (_local2 < _local4) {
				_local3 = _items[_local2];
				if (_local3.visible){
					_arg1.lineStyle(1, 0);
				} else {
					_arg1.lineStyle(1, 0x999999);
				};
				switch (_local3.type){
					case WALL:
						DEBUG_DRAW_WALL(_arg1, _local3);
						break;
					case POLYGON:
						DEBUG_DRAW_POLYGON(_arg1, _local3);
						break;
					case FLIPPER:
						DEBUG_DRAW_FLIPPER(_arg1, _local3);
						break;
					case TRIGGER:
						_arg1.lineStyle(1, 0xFF0000);
					case BUMPER:
						DEBUG_DRAW_BUMPER(_arg1, _local3);
						break;
					case BALL:
				};
				_local2++;
			};
		}
		public function set itemBounceTime(_arg1:Number){
			if (_arg1 < 0){
				_arg1 = 0;
			};
			_itemBounceTime = _arg1;
		}
		public function set itemBounceOffset(_arg1:Number){
			_itemBounceOffset = _arg1;
		}
		public function addTrigger(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:MovieClip):Object{
			var _local5:Object;
			_local5 = {visible:true, type:TRIGGER, x:_arg1, y:_arg2, radius:_arg3, clip:_arg4, multiplier:1};
			_arg4.x = _arg1;
			_arg4.y = _arg2;
			_local5.minY = _local5.y;
			_triggerClip.addChild(_local5.clip);
			_local5.clip.gotoAndStop(1);
			_triggers.push(_local5);
			return (_local5);
		}
		public function get itemBounceOffset():Number{
			return (_itemBounceOffset);
		}
		public function getFlipperID(_arg1:Object):int{
			var _local2:int;
			var _local3:int;
			_local3 = _flippers.length;
			_local2 = 0;
			while (_local2 < _local3) {
				if (_flippers[_local2] == _arg1){
					return (_local2);
				};
				_local2++;
			};
			return (-1);
		}
		public function get ball():Object{
			return (_ball);
		}

		public static function ballHitCircle(_arg1:Object, _arg2:Object, _arg3:Number):Array{
			var _local4:Boolean;
			var _local5:Number;
			var _local6:Number;
			var _local7:Object;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Array;
			var _local19:int;
			var _local20:Object;
			var _local21:Number;
			var _local22:Number;
			var _local23:Number;
			var _local24:Object;
			var _local25:Number;
			var _local26:Number;
			var _local27:Number;
			var _local28:Number;
			var _local29:*;
			var _local30:*;
			_local4 = false;
			_local5 = Math.sqrt(((_arg1.vX * _arg1.vX) + (_arg1.vY * _arg1.vY)));
			_local6 = (1 / _local5);
			if (!_local5){
				_local6 = 0;
			};
			_local7 = {x:(_arg1.vX * _local6), y:(_arg1.vY * _local6)};
			_local8 = (Math.min(_arg1.remaining, _arg3) + _local6);
			_local9 = (_arg1.vX * _local8);
			_local10 = (_arg1.vY * _local8);
			_local11 = _arg1.radius;
			_local12 = _arg2.radius;
			_local13 = (_local11 + _local12);
			_local14 = ((_local11 + _local12) * _local13);
			do  {
				_local15 = (_arg1.x - _arg2.x);
				_local16 = (_arg1.y - _arg2.y);
				_local17 = ((_local15 * _local15) + (_local16 * _local16));
			} while (!(_local17 < _local14));
			if (!_local4){
				return ([]);
			};
			if (((!((_arg1.vX == 0))) && (!((_arg1.vY == 0))))){
				_local20 = projectPointOnLine(_arg2.x, _arg2.y, _arg1.x, _arg1.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vY));
			} else {
				_local20 = projectPointOnLine(_arg2.x, _arg2.y, _arg1.x, _arg1.y, (_arg1.x + 1), _arg1.y);
			};
			_local15 = (_local20.x - _arg2.x);
			_local16 = (_local20.y - _arg2.y);
			_local21 = Math.sqrt(((_local15 * _local15) + (_local16 * _local16)));
			_local22 = Math.asin(Math.min(Math.max((_local21 / _local13), -1), 1));
			_local23 = (Math.cos(_local22) * _local13);
			_local24 = {x:(_local20.x - (_local23 * _local7.x)), y:(_local20.y - (_local23 * _local7.y))};
			if (!_local5){
				_local22 = Math.atan2((_arg1.y - _arg2.y), (_arg1.x - _arg2.x));
			} else {
				_local22 = Math.atan2((_local24.y - _arg2.y), (_local24.x - _arg2.x));
			};
			_local25 = Math.cos(_local22);
			_local26 = Math.sin(_local22);
			_local27 = -(_local26);
			_local28 = _local25;
			_local24.x = (_arg2.x + (_local25 * _local12));
			_local24.y = (_arg2.y + (_local26 * _local12));
			if (((_arg1.vX * _local25) + (_arg1.vY * _local26)) > 0){
				return ([]);
			};
			return ([{x0:(_local24.x - _local27), y0:(_local24.y - _local28), x1:(_local24.x + _local27), y1:(_local24.y + _local28), item:_arg2}]);
		}
		public static function pointInsideRect(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number){
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			if (_arg3 < _arg5){
				_local7 = _arg3;
				_local9 = _arg5;
			} else {
				_local7 = _arg5;
				_local9 = _arg3;
			};
			if (_arg4 < _arg6){
				_local8 = _arg4;
				_local10 = _arg6;
			} else {
				_local8 = _arg6;
				_local10 = _arg4;
			};
			_local11 = 0.0001;
			return (!((((((((_arg1 < (_local7 - _local11))) || ((_arg1 > (_local9 + _local11))))) || ((_arg2 < (_local8 - _local11))))) || ((_arg2 > (_local10 + _local11))))));
		}
		public static function ballHitFlipper(_arg1:Object, _arg2:Object, _arg3:Number):Array{
			var _local4:int;
			var _local5:int;
			var _local6:Array;
			var _local7:Array;
			var _local8:Array;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Array;
			var _local19:Object;
			var _local20:Object;
			var _local21:Object;
			var _local22:Object;
			var _local23:Boolean;
			var _local24:Boolean;
			var _local25:Boolean;
			var _local26:Boolean;
			var _local27:Number;
			var _local28:Number;
			var _local29:Number;
			var _local30:Object;
			var _local31:Number;
			var _local32:Number;
			var _local33:Number;
			var _local34:Number;
			if (!_arg2.updated){
				return (ballHitStaticFlipper(_arg1, _arg2, _arg3));
			};
			_local9 = (_arg2.length + _arg2.minRadius);
			_local10 = _arg2.angle;
			_local11 = _arg2.oldAngle;
			if (_local10 > _local11){
				_local10 = _arg2.oldAngle;
				_local11 = _arg2.angle;
			};
			_local12 = (_arg1.x - _arg2.x);
			_local13 = (_arg1.y - _arg2.y);
			_local14 = Math.sqrt(((_local12 * _local12) + (_local13 * _local13)));
			if (_local14 > _local9){
				return (ballHitStaticFlipper(_arg1, _arg2, _arg3));
			};
			_local15 = Math.atan2(_local13, _local12);
			_local12 = (_local12 + _arg1.vX);
			_local13 = (_local13 + _arg1.vY);
			_local16 = Math.sqrt(((_local12 * _local12) + (_local13 * _local13)));
			_local17 = Math.atan2(_local13, _local12);
			while (_local15 > _local11) {
				_local15 = (_local15 - (Math.PI * 2));
			};
			while (_local15 < _local10) {
				_local15 = (_local15 + (Math.PI * 2));
			};
			while (_local17 > _local11) {
				_local17 = (_local17 - (Math.PI * 2));
			};
			while (_local17 < _local10) {
				_local17 = (_local17 + (Math.PI * 2));
			};
			_local18 = _arg2.poly;
			_local19 = _local18[0];
			_local20 = _local18[1];
			_local21 = _local18[2];
			_local22 = _local18[3];
			if (_arg2.angle < _arg2.oldAngle){
				_local23 = (lineHitCircle(_local19.x, _local19.y, _local20.x, _local20.y, _arg1.x, _arg1.y, _arg1.radius).length > 0);
				_local24 = (lineHitCircle(_local19.x, _local19.y, _local20.x, _local20.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vX), _arg1.radius).length > 0);
			} else {
				_local23 = (lineHitCircle(_local21.x, _local21.y, _local22.x, _local22.y, _arg1.x, _arg1.y, _arg1.radius).length > 0);
				_local24 = (lineHitCircle(_local21.x, _local21.y, _local22.x, _local22.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vY), _arg1.radius).length > 0);
			};
			_local25 = (_local15 <= _local11);
			_local26 = (_local17 < _local11);
			if (!((_local23) || (_local25))){
				return (ballHitStaticFlipper(_arg1, _arg2, _arg3));
			};
			_local27 = _arg2.angle;
			_local28 = Math.cos(_local27);
			_local29 = Math.sin(_local27);
			_local30 = {x:0, y:0};
			_local31 = (_arg2.maxRadius + ((_local14 / _arg2.length) * (_arg2.minRadius - _arg2.maxRadius)));
			if (_arg2.angle > _arg2.oldAngle){
				_local30.x = ((_arg2.x + (_local28 * _local14)) - (_local29 * (_arg1.radius + _local31)));
				_local30.y = ((_arg2.y + (_local29 * _local14)) + (_local28 * (_arg1.radius + _local31)));
			} else {
				_local30.x = ((_arg2.x + (_local28 * _local14)) + (_local29 * (_arg1.radius + _local31)));
				_local30.y = ((_arg2.y + (_local29 * _local14)) - (_local28 * (_arg1.radius + _local31)));
			};
			_arg1.x = _local30.x;
			_arg1.y = _local30.y;
			if (_arg2.oldAngle > _arg2.angle){
				_local32 = Math.cos((_arg2.angle - (Math.PI * 0.5)));
				_local33 = Math.sin((_arg2.angle - (Math.PI * 0.5)));
			} else {
				_local32 = Math.cos((_arg2.angle + (Math.PI * 0.5)));
				_local33 = Math.sin((_arg2.angle + (Math.PI * 0.5)));
			};
			if (((_arg1.vX * _local32) + (_arg1.vY * _local33)) > 0){
				_local34 = Math.sqrt(((_arg1.vX * _arg1.vX) + (_arg1.vY * _arg1.vY)));
				_arg1.vX = (_arg1.vX + (_local32 * _local34));
				_arg1.vY = (_arg1.vY + (_local33 * _local34));
			};
			return (ballHitStaticFlipper(_arg1, _arg2, _arg3));
		}
		public static function ballHitPolygon(_arg1:Object, _arg2:Object, _arg3:Number):Array{
			var _local4:Array;
			var _local5:int;
			var _local6:Object;
			var _local7:Object;
			var _local8:int;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Boolean;
			var _local13:Array;
			_local4 = _arg2.poly;
			_local5 = _local4.length;
			if (_local5 < 2){
				return (null);
			};
			_local9 = Infinity;
			_local13 = [];
			_local8 = 0;
			while (_local8 < _local5) {
				_local6 = _local4[_local8];
				_local7 = _local4[((_local8 + 1) % _local5)];
				_local12 = ballHitLine(_arg1, {x0:_local6.x, y0:_local6.y, x1:_local7.x, y1:_local7.y}, _arg3);
				if (_local12){
					_local13[_local13.length] = {x0:_local6.x, y0:_local6.y, x1:_local7.x, y1:_local7.y, item:_arg2};
				};
				_local8++;
			};
			if (((!(_local13.length)) && (pointInsidePolygon(_arg1.x, _arg1.y, _local4)))){
				_local13[0] = {x0:_local6.x, y0:_local6.y, x1:_local7.x, y1:_local7.y, item:_arg2};
			};
			return (_local13);
		}
		public static function ballHitStaticFlipper(_arg1:Object, _arg2:Object, _arg3:Number){
			var _local4:Array;
			var _local5:Array;
			var _local6:Array;
			var _local7:Object;
			var _local8:int;
			var _local9:int;
			var _local10:Array;
			var _local11:Array;
			var _local12:Number;
			var _local13:Number;
			_local10 = _arg2.poly;
			_local4 = [];
			_local7 = {x0:_local10[0].x, y0:_local10[0].y, x1:_local10[1].x, y1:_local10[1].y, item:_arg2};
			if (ballHitLine(_arg1, _local7, _arg3)){
				_local4[0] = _local7;
			};
			_local7 = {x0:_local10[2].x, y0:_local10[2].y, x1:_local10[3].x, y1:_local10[3].y, item:_arg2};
			if (ballHitLine(_arg1, _local7, _arg3)){
				_local4[_local4.length] = _local7;
			};
			_local5 = ballHitCircle(_arg1, {x:_arg2.x, y:_arg2.y, radius:_arg2.maxRadius}, _arg3);
			if (((1) || (!(_arg2.updated)))){
				_local12 = (_arg2.x + (Math.cos(_arg2.angle) * _arg2.length));
				_local13 = (_arg2.y + (Math.sin(_arg2.angle) * _arg2.length));
				_local6 = ballHitCircle(_arg1, {x:_local12, y:_local13, radius:_arg2.minRadius}, _arg3);
			} else {
				_local6 = [];
			};
			_local11 = [];
			if (_local4.length){
				_local11 = _local11.concat(_local4);
			};
			if (_local5.length){
				_local11 = _local11.concat(_local5);
			};
			if (_local6.length){
				_local11 = _local11.concat(_local6);
			};
			_local9 = _local11.length;
			_local8 = 0;
			while (_local8 < _local9) {
				_local11[_local8].item = _arg2;
				_local8++;
			};
			return (_local11);
		}
		public static function projectPointOnLine(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number):Object{
			var _local7:Object;
			_local7 = {x:(_arg6 - _arg4), y:(_arg3 - _arg5)};
			return (intersectLines(_arg3, _arg4, _arg5, _arg6, _arg1, _arg2, (_arg1 + _local7.x), (_arg2 + _local7.y)));
		}
		public static function newBallHitFlipper(_arg1:Object, _arg2:Object, _arg3:Number):Array{
			var _local4:Boolean;
			var _local5:Boolean;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Object;
			var _local18:Object;
			var _local19:*;
			var _local20:*;
			var _local21:*;
			var _local22:*;
			var _local23:*;
			var _local24:*;
			var _local25:*;
			var _local26:*;
			var _local27:*;
			var _local28:*;
			var _local29:*;
			_local4 = false;
			_local5 = false;
			_local6 = _arg1.x;
			_local7 = _arg1.y;
			_local8 = _arg1.radius;
			_local9 = _arg2.x;
			_local10 = _arg2.y;
			_local11 = _arg2.angle;
			_local12 = _arg2.oldAngle;
			_local15 = (_arg2.length + _arg2.minRadius);
			_local16 = (Math.PI * 2);
			do  {
			} while (_arg2.updated);
			return (ballHitStaticFlipper(_arg1, _arg2, _arg3));
		}
		public static function moveBallToLine(_arg1:Object, _arg2:Object):Number{
			var _local3:Number;
			var _local4:Number;
			var _local5:Object;
			var _local6:Object;
			var _local7:Number;
			var _local8:Object;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Object;
			var _local19:Object;
			var _local20:Number;
			var _local21:Number;
			var _local22:Number;
			var _local23:Number;
			var _local24:Object;
			var _local25:Object;
			var _local26:Boolean;
			var _local27:Boolean;
			var _local28:Number;
			var _local29:Object;
			var _local30:Number;
			var _local31:Number;
			var _local32:Array;
			var _local33:Array;
			if ((((Math.abs(_arg1.vX) < 0.0001)) && ((Math.abs(_arg1.vY) < 0.0001)))){
				if (lineHitCircle(_arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1, _arg1.x, _arg1.y, _arg1.radius)){
					return (0);
				};
				return (1);
			};
			_local3 = Math.sqrt(((_arg1.vX * _arg1.vX) + (_arg1.vY * _arg1.vY)));
			_local4 = (1 / _local3);
			_local5 = {vX:(_arg1.vX * _local4), vY:(_arg1.vY * _local4)};
			_local6 = {x:(_arg2.y1 - _arg2.y0), x:(_arg2.x0 - _arg2.x1)};
			_local7 = Math.sqrt(((_local6.x * _local6.x) + (_local6.y * _local6.y)));
			_local8 = intersectLines(_arg1.x, _arg1.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vY), _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1);
			if (!_local8){
				return (1);
			};
			_local9 = (_local8.x - _arg1.x);
			_local10 = (_local8.y - _arg1.y);
			if (((_local9 * _arg1.vX) + (_local10 * _arg1.vY)) < 0){
				return (-1);
			};
			_local11 = Math.sqrt(((_local9 * _local9) + (_local10 * _local10)));
			_local12 = Math.atan2(_arg1.vY, _arg1.vX);
			_local13 = Math.atan2((_arg2.y1 - _arg2.y0), (_arg2.x1 - _arg2.x0));
			_local14 = (_local12 - _local13);
			_local15 = Math.abs(Math.sin(_local14));
			_local16 = (_arg1.radius / _local15);
			_local17 = _local16;
			if (_local15 == 0){
				_local17 = _local11;
			};
			_local23 = -1;
			_local22 = _local23;
			_local20 = -1;
			_local21 = -1;
			_local24 = {x:(_local8.x - (_local16 * _local5.vX)), y:(_local8.y - (_local16 * _local5.vY))};
			_local25 = projectPointOnLine(_local24.x, _local24.y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1);
			_local26 = false;
			_local27 = false;
			if (!pointInsideRect(_local25.x, _local25.y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1)){
				_local26 = true;
				_local29 = intersectLines(_arg2.x0, _arg2.y0, (_arg2.x0 + _local5.vY), (_arg2.y0 - _local5.vX), _arg1.x, _arg1.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vY));
				_local9 = (_local29.x - _arg1.x);
				_local10 = (_local29.y - _arg1.y);
				_local30 = Math.sqrt(((_local9 * _local9) + (_local10 * _local10)));
				_local9 = (_local29.x - _arg2.x0);
				_local10 = (_local29.y - _arg2.y0);
				_local22 = Math.sqrt(((_local9 * _local9) + (_local10 * _local10)));
				if (_local22 < _arg1.radius){
					_local32 = lineHitCircle((_arg2.x0 - ((_local5.vX * _arg1.radius) * 2)), (_arg2.y0 - ((_local5.vY * _arg1.radius) * 2)), (_arg2.x0 + ((_local5.vX * _arg1.radius) * 2)), (_arg2.y0 + ((_local5.vY * _arg1.radius) * 2)), _local29.x, _local29.y, _arg1.radius);
					if (_local32.length == 2){
						_local9 = (_local32[0].x - _arg2.x0);
						_local10 = (_local32[0].y - _arg2.y0);
						_local9 = (_local32[0].x - _arg2.x0);
						_local10 = (_local32[0].y - _arg2.y0);
						if (((_local9 * _arg1.vX) + (_local10 * _arg1.vY)) < 0){
							_local9 = (_local32[1].x - _arg2.x0);
							_local10 = (_local32[1].y - _arg2.y0);
						};
						_local20 = (_local30 - Math.sqrt(((_local9 * _local9) + (_local10 * _local10))));
						_local27 = true;
					};
				};
				_local29 = intersectLines(_arg2.x1, _arg2.y1, (_arg2.x1 + _local5.vY), (_arg2.y1 - _local5.vX), _arg1.x, _arg1.y, (_arg1.x + _arg1.vX), (_arg1.y + _arg1.vY));
				_local9 = (_local29.x - _arg1.x);
				_local10 = (_local29.y - _arg1.y);
				_local31 = Math.sqrt(((_local9 * _local9) + (_local10 * _local10)));
				_local9 = (_local29.x - _arg2.x1);
				_local10 = (_local29.y - _arg2.y1);
				_local23 = Math.sqrt(((_local9 * _local9) + (_local10 * _local10)));
				if (_local23 < _arg1.radius){
					_local33 = lineHitCircle((_arg2.x1 - ((_local5.vX * _arg1.radius) * 2)), (_arg2.y1 - ((_local5.vY * _arg1.radius) * 2)), (_arg2.x1 + ((_local5.vX * _arg1.radius) * 2)), (_arg2.y1 + ((_local5.vY * _arg1.radius) * 2)), _local29.x, _local29.y, _arg1.radius);
					if (_local33.length == 2){
						_local9 = (_local33[0].x - _arg2.x1);
						_local10 = (_local33[0].y - _arg2.y1);
						if (((_local9 * _arg1.vX) + (_local10 * _arg1.vY)) < 0){
							_local9 = (_local33[1].x - _arg2.x1);
							_local10 = (_local33[1].y - _arg2.y1);
						};
						_local21 = (_local31 - Math.sqrt(((_local9 * _local9) + (_local10 * _local10))));
						_local27 = true;
					};
				};
			};
			if (((_local26) && (!(_local27)))){
				return (1);
			};
			if ((((((_local20 >= 0)) && ((_local20 < _local21)))) || ((_local21 <= 0)))){
				_local28 = _local20;
			} else {
				_local28 = _local21;
			};
			if (_local26){
				return ((_local28 / _local3));
			};
			return (Math.max(((_local11 - _local17) / _local3), 0));
		}
		public static function moveBallOnFlipper(_arg1:Object, _arg2:Array):Array{
			var _local3:int;
			var _local4:Number;
			var _local5:Object;
			var _local6:Object;
			var _local7:Object;
			var _local8:Object;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Object;
			var _local16:Object;
			var _local17:Array;
			var _local18:int;
			_local3 = _arg2.length;
			if (!_local3){
				return ([]);
			};
			_local4 = Infinity;
			_local5 = {x:0, y:0};
			_local6 = _arg2[0].item;
			_local8 = {x:0, y:0};
			_local12 = _arg1.x;
			_local13 = _arg1.y;
			_local14 = _arg1.radius;
			_local16 = {x:0, y:0};
			_local17 = [];
			_local18 = 0;
			while (_local18 < _arg2.length) {
				_local7 = _arg2[_local18];
				_local9 = (_local7.y1 - _local7.y0);
				_local10 = (_local7.x0 - _local7.x1);
				_local11 = (1 / Math.sqrt(((_local9 * _local9) + (_local10 * _local10))));
				_local8.x = (_local11 * _local9);
				_local8.y = (_local11 * _local10);
				_local16.x = (_local12 - (_local8.x * _local14));
				_local16.y = (_local13 - (_local8.y * _local14));
				_local15 = intersectLines(_local7.x0, _local7.y0, _local7.x1, _local7.y1, _local16.x, _local16.y, (_local16.x + _local9), (_local16.y + _local10));
				_local9 = (_local15.x - _local16.x);
				_local10 = (_local15.y - _local16.y);
				_local11 = ((_local9 * _local9) + (_local10 * _local10));
				if ((((((_local9 * _local8.x) + (_local10 * _local8.y)) >= 0)) && ((_local11 < _local4)))){
					_local17[0] = _local7;
					_local4 = _local11;
					_local5.x = _local9;
					_local5.y = _local10;
				};
				_local18++;
			};
			if (_local4 < Infinity){
				_arg1.x = (_arg1.x + _local5.x);
				_arg1.y = (_arg1.y + _local5.y);
			};
			return (_local17);
		}
		public static function intersectLines(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number, _arg8:Number, _arg9:Boolean=false):Object{
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Object;
			var _local19:Boolean;
			var _local20:Boolean;
			_local10 = (_arg1 - _arg3);
			_local11 = (_arg5 - _arg7);
			_local12 = (_arg2 - _arg4);
			_local13 = (_arg6 - _arg8);
			_local14 = ((_arg1 * _arg4) - (_arg2 * _arg3));
			_local15 = ((_arg5 * _arg8) - (_arg6 * _arg7));
			_local16 = ((_local10 * _local13) - (_local12 * _local11));
			if (!_local16){
				return (null);
			};
			_local17 = (1 / _local16);
			_local18 = {x:(((_local14 * _local11) - (_local10 * _local15)) * _local17), y:(((_local14 * _local13) - (_local12 * _local15)) * _local17)};
			if (_arg9){
				_local19 = pointInsideRect(_local18.x, _local18.y, _arg1, _arg2, _arg3, _arg4);
				_local20 = pointInsideRect(_local18.x, _local18.y, _arg5, _arg6, _arg7, _arg8);
				if (((!(_local19)) || (!(_local20)))){
					return (null);
				};
			};
			return (_local18);
		}
		public static function rotate(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number=0, _arg5:Number=0){
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			_local6 = Math.cos(_arg3);
			_local7 = Math.sin(_arg3);
			_local8 = (_arg1 - _arg4);
			_local9 = (_arg2 - _arg5);
			_local10 = ((_local6 * _local8) - (_local7 * _local9));
			_local11 = ((_local7 * _local8) + (_local6 * _local9));
			return ({x:(_arg4 + _local10), y:(_arg5 + _local11)});
		}
		public static function moveBallUp(_arg1:Object, _arg2:Object):void{
			var _local3:Object;
			var _local4:Number;
			var _local5:Object;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			_local3 = {x:(_arg2.y1 - _arg2.y0), y:(_arg2.x0 - _arg2.x1)};
			_local4 = (1 / Math.sqrt(((_local3.x * _local3.x) + (_local3.y * _local3.y))));
			_local3.x = (_local3.x * _local4);
			_local3.y = (_local3.y * _local4);
			_local5 = projectPointOnLine(_arg1.x, _arg1.y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1);
			_local6 = (_local5.x - _arg1.x);
			_local7 = (_local5.y - _arg1.y);
			_local8 = Math.sqrt(((_local6 * _local6) + (_local7 * _local7)));
			if (_local8 > _arg1.radius){
				return;
			};
			if (((_local3.x * _local6) + (_local3.y * _local7)) < 0){
				_local9 = ((_arg1.radius + _local8) + 1);
			} else {
				_local9 = ((_arg1.radius - _local8) + 1);
			};
			_arg1.x = (_arg1.x + (_local3.x * _local9));
			_arg1.y = (_arg1.y + (_local3.y * _local9));
		}
		public static function pointInsidePolygon(_arg1:Number, _arg2:Number, _arg3:Object):Boolean{
			var _local4:int;
			var _local5:int;
			var _local6:Object;
			var _local7:Object;
			var _local8:Object;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Array;
			var _local14:int;
			var _local15:int;
			var _local16:int;
			if (_arg3.length < 3){
				return (false);
			};
			_local5 = _arg3.length;
			_local13 = [];
			_local15 = 0;
			_local16 = 0;
			_local14 = 0;
			while (_local14 < DIRECTIONS.length) {
				_local11 = DIRECTIONS[_local14][0];
				_local12 = DIRECTIONS[_local14][1];
				_local13[_local14] = 0;
				_local4 = 0;
				while (_local4 < _local5) {
					_local7 = _arg3[_local4];
					_local8 = _arg3[((_local4 + 1) % _arg3.length)];
					_local6 = intersectLines((_arg1 + _local11), (_arg2 + _local12), _arg1, _arg2, _local7.x, _local7.y, _local8.x, _local8.y);
					if (((((_local6) && (pointInsideRect(_local6.x, _local6.y, _local7.x, _local7.y, _local8.x, _local8.y)))) && ((((_local11 * (_local6.x - _arg1)) + (_local12 * (_local6.y - _arg2))) > 0)))){
						var _local17 = _local13;
						var _local18 = _local14;
						var _local19 = (_local17[_local18] + 1);
						_local17[_local18] = _local19;
					};
					_local4++;
				};
				if ((_local13[_local14] % 2)){
					_local16++;
				} else {
					_local15++;
				};
				_local14++;
			};
			return ((_local16 > _local15));
		}
		public static function ballHitLine(_arg1:Object, _arg2:Object, _arg3:Number):Boolean{
			var _local4:Object;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Object;
			var _local9:Number;
			var _local10:Number;
			var _local11:int;
			var _local12:Object;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Array;
			var _local18:Number;
			var _local19:Number;
			var _local20:Number;
			var _local21:Number;
			var _local22:Array;
			var _local23:Boolean;
			_local4 = {x:(_arg2.y1 - _arg2.y0), y:(_arg2.x0 - _arg2.x1)};
			_local5 = (1 / Math.sqrt(((_local4.x * _local4.x) + (_local4.y * _local4.y))));
			_local4.x = (_local4.x * _local5);
			_local4.y = (_local4.y * _local5);
			_local6 = Math.sqrt(((_arg1.vX * _arg1.vX) + (_arg1.vY * _arg1.vY)));
			_local7 = (1 / _local6);
			if (!_local6){
				_local7 = 0;
			};
			_local8 = {x:(_arg1.vX * _local7), y:(_arg1.vY * _local7)};
			_local9 = ((_local4.x * _local8.x) + (_local4.y * _local8.y));
			if (_local9 > 0){
				return (false);
			};
			_local10 = (Math.min(_arg1.remaining, _arg3) + _local7);
			_local13 = (_local8.y * _arg1.radius);
			_local14 = (-(_local8.x) * _arg1.radius);
			_local15 = (_arg1.vX * _local10);
			_local16 = (_arg1.vY * _local10);
			_local17 = [{x:(_arg1.x + _local13), y:(_arg1.y + _local14)}, {x:((_arg1.x + _local15) + _local13), y:((_arg1.y + _local16) + _local14)}, {x:((_arg1.x + _local15) - _local13), y:((_arg1.y + _local16) - _local14)}, {x:(_arg1.x - _local13), y:(_arg1.y - _local14)}];
			_local18 = (_arg1.radius * _arg1.radius);
			_local19 = (_arg2.x0 - _arg1.x);
			_local20 = (_arg2.y0 - _arg1.y);
			_local21 = ((_local19 * _local19) + (_local20 * _local20));
			if (_local21 <= _local18){
				return (true);
			};
			_local19 = (_arg2.x1 - _arg1.x);
			_local20 = (_arg2.y1 - _arg1.y);
			_local21 = ((_local19 * _local19) + (_local20 * _local20));
			if (_local21 <= _local18){
				return (true);
			};
			_local19 = (_arg2.x0 - (_arg1.x + _local15));
			_local20 = (_arg2.y0 - (_arg1.y + _local16));
			_local21 = ((_local19 * _local19) + (_local20 * _local20));
			if (_local21 <= _local18){
				return (true);
			};
			_local19 = (_arg2.x1 - (_arg1.x + _local15));
			_local20 = (_arg2.y1 - (_arg1.y + _local16));
			_local21 = ((_local19 * _local19) + (_local20 * _local20));
			if (_local21 <= _local18){
				return (true);
			};
			if (pointInsidePolygon(_arg2.x0, _arg2.y0, _local17)){
				return (true);
			};
			if (pointInsidePolygon(_arg2.x1, _arg2.y1, _local17)){
				return (true);
			};
			_local22 = lineHitCircle(_arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1, _arg1.x, _arg1.y, _arg1.radius);
			_local11 = 0;
			while (_local11 < _local22.length) {
				if (pointInsideRect(_local22[_local11].x, _local22[_local11].y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1)){
					return (true);
				};
				_local11++;
			};
			_local22 = lineHitCircle(_arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1, (_arg1.x + (_arg1.vX * _local10)), (_arg1.y + (_arg1.vY * _local10)), _arg1.radius);
			_local11 = 0;
			while (_local11 < _local22.length) {
				if (pointInsideRect(_local22[_local11].x, _local22[_local11].y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1)){
					return (true);
				};
				_local11++;
			};
			_local23 = false;
			_local12 = intersectLines(_local17[0].x, _local17[0].y, _local17[1].x, _local17[1].y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1, true);
			if (_local12){
				return (true);
			};
			_local12 = intersectLines(_local17[3].x, _local17[3].y, _local17[2].x, _local17[2].y, _arg2.x0, _arg2.y0, _arg2.x1, _arg2.y1, true);
			if (_local12){
				return (true);
			};
			return (false);
		}
		public static function lineHitCircle(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number):Array{
			var _local8:Number;
			var _local9:Object;
			var _local10:Object;
			var _local11:Object;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Array;
			_local8 = Math.atan2((_arg4 - _arg2), (_arg3 - _arg1));
			_local9 = rotate((_arg1 - _arg1), (_arg2 - _arg2), -(_local8));
			_local10 = rotate((_arg3 - _arg1), (_arg4 - _arg2), -(_local8));
			_local11 = rotate((_arg5 - _arg1), (_arg6 - _arg2), -(_local8));
			_local12 = _local11.x;
			_local13 = _local9.y;
			_local9.x = (_local9.x - _local12);
			_local10.x = (_local10.x - _local12);
			_local11.x = (_local11.x - _local12);
			_local9.y = (_local9.y - _local13);
			_local10.y = (_local10.y - _local13);
			_local11.y = (_local11.y - _local13);
			if ((((_local11.y < -(_arg7))) || ((_local11.y > _arg7)))){
				return ([]);
			};
			_local14 = (_local11.y * _local11.y);
			_local15 = (_arg7 * _arg7);
			_local16 = Math.sqrt((_local15 - _local14));
			_local17 = -(_local16);
			_local18 = [];
			if ((((_local16 >= _local9.x)) && ((_local16 <= _local10.x)))){
				_local18[0] = rotate((_local16 + _local12), _local13, _local8);
				_local18[0].x = (_local18[0].x + _arg1);
				_local18[0].y = (_local18[0].y + _arg2);
			};
			if ((((_local17 >= _local9.x)) && ((_local17 <= _local10.x)))){
				_local18[_local18.length] = rotate((_local17 + _local12), _local13, _local8);
				_local18[(_local18.length - 1)].x = (_local18[(_local18.length - 1)].x + _arg1);
				_local18[(_local18.length - 1)].y = (_local18[(_local18.length - 1)].y + _arg2);
			};
			return (_local18);
		}
		public static function lineHitPolygon(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Array):Boolean{
			var _local6:int;
			var _local7:int;
			var _local8:Object;
			var _local9:Object;
			_local7 = (_arg5.length - 1);
			_local6 = 0;
			while (_local6 < _local7) {
				_local8 = _arg5[_local6];
				_local9 = _arg5[(_local6 + 1)];
				if (intersectLines(_arg1, _arg2, _arg3, _arg4, _local8.x, _local8.y, _local9.x, _local9.y, true)){
					return (true);
				};
				_local6++;
			};
			_local8 = _arg5[_local6];
			_local9 = _arg5[0];
			if (intersectLines(_arg1, _arg2, _arg3, _arg4, _local8.x, _local8.y, _local9.x, _local9.y, true)){
				return (true);
			};
			if (pointInsidePolygon(_arg1, _arg2, _arg5)){
				return (true);
			};
			if (pointInsidePolygon(_arg3, _arg4, _arg5)){
				return (true);
			};
			return (false);
		}
		public static function reflect(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number){
			var _local7:Object;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			_local7 = {vX:(_arg6 - _arg4), vY:(_arg3 - _arg5)};
			_local8 = (1 / Math.sqrt(((_local7.vX * _local7.vX) + (_local7.vY * _local7.vY))));
			_local7.vX = (_local7.vX * _local8);
			_local7.vY = (_local7.vY * _local8);
			_local9 = Math.sqrt(((_arg1 * _arg1) + (_arg2 * _arg2)));
			_local10 = (1 / _local9);
			_arg1 = (_arg1 * _local10);
			_arg2 = (_arg2 * _local10);
			_local11 = (2 * ((_arg1 * _local7.vX) + (_arg2 * _local7.vY)));
			return ({vX:((_arg1 - (_local11 * _local7.vX)) * _local9), vY:((_arg2 - (_local11 * _local7.vY)) * _local9)});
		}
		public static function ballHitWall(_arg1:Object, _arg2:Object, _arg3:Number):Array{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Object;
			var _local10:Object;
			var _local11:Array;
			var _local12:Array;
			var _local13:int;
			var _local14:int;
			_local4 = Math.atan2((_arg2.y1 - _arg2.y0), (_arg2.x1 - _arg2.x0));
			_local5 = (Math.cos(_local4) * _arg2.thickness);
			_local6 = (Math.sin(_local4) * _arg2.thickness);
			_local7 = _local6;
			_local8 = -(_local5);
			_local9 = {x:(_arg2.x0 - _local5), y:(_arg2.y0 - _local6)};
			_local10 = {x:(_arg2.x1 + _local5), y:(_arg2.y1 + _local6)};
			_local11 = [{x:(_local9.x + _local7), y:(_local9.y + _local8)}, {x:(_local10.x + _local7), y:(_local10.y + _local8)}, {x:(_local10.x - _local7), y:(_local10.y - _local8)}, {x:(_local9.x - _local7), y:(_local9.y - _local8)}];
			_local12 = ballHitPolygon(_arg1, {poly:_local11}, _arg3);
			_local13 = _local12.length;
			_local14 = 0;
			while (_local14 < _local13) {
				_local12[_local14].item = _arg2;
				_local14++;
			};
			return (_local12);
		}

	}
}//package pinball 
Section 5
//AmberCatchClip (AmberCatchClip)
package {
	import flash.display.*;

	public dynamic class AmberCatchClip extends MovieClip {

		public var ball:MovieClip;

	}
}//package 
Section 6
//AmberInflateClip (AmberInflateClip)
package {
	import flash.display.*;

	public dynamic class AmberInflateClip extends MovieClip {

		public var belly1:MovieClip;
		public var belly2:MovieClip;

	}
}//package 
Section 7
//ballClip (ballClip)
package {
	import flash.display.*;

	public dynamic class ballClip extends MovieClip {

	}
}//package 
Section 8
//barrier_mc (barrier_mc)
package {
	import flash.display.*;

	public dynamic class barrier_mc extends MovieClip {

	}
}//package 
Section 9
//bell_mc (bell_mc)
package {
	import flash.display.*;

	public dynamic class bell_mc extends MovieClip {

	}
}//package 
Section 10
//blueBalloonBumper_mc (blueBalloonBumper_mc)
package {
	import flash.display.*;

	public dynamic class blueBalloonBumper_mc extends MovieClip {

	}
}//package 
Section 11
//blueTopBumper_mc (blueTopBumper_mc)
package {
	import flash.display.*;

	public dynamic class blueTopBumper_mc extends MovieClip {

	}
}//package 
Section 12
//bouncyLeft_mc (bouncyLeft_mc)
package {
	import flash.display.*;

	public dynamic class bouncyLeft_mc extends MovieClip {

	}
}//package 
Section 13
//bouncyRight_mc (bouncyRight_mc)
package {
	import flash.display.*;

	public dynamic class bouncyRight_mc extends MovieClip {

	}
}//package 
Section 14
//bouncySwitch_mc (bouncySwitch_mc)
package {
	import flash.display.*;

	public dynamic class bouncySwitch_mc extends MovieClip {

	}
}//package 
Section 15
//caveLight_mc (caveLight_mc)
package {
	import flash.display.*;

	public dynamic class caveLight_mc extends MovieClip {

	}
}//package 
Section 16
//entranceDoor_mc (entranceDoor_mc)
package {
	import flash.display.*;

	public dynamic class entranceDoor_mc extends MovieClip {

	}
}//package 
Section 17
//flipperLeft_mc (flipperLeft_mc)
package {
	import flash.display.*;

	public dynamic class flipperLeft_mc extends MovieClip {

	}
}//package 
Section 18
//flipperRight_mc (flipperRight_mc)
package {
	import flash.display.*;

	public dynamic class flipperRight_mc extends MovieClip {

	}
}//package 
Section 19
//gemLeft_mc (gemLeft_mc)
package {
	import flash.display.*;

	public dynamic class gemLeft_mc extends MovieClip {

	}
}//package 
Section 20
//gemRight_mc (gemRight_mc)
package {
	import flash.display.*;

	public dynamic class gemRight_mc extends MovieClip {

	}
}//package 
Section 21
//goldBumper_mc (goldBumper_mc)
package {
	import flash.display.*;

	public dynamic class goldBumper_mc extends MovieClip {

	}
}//package 
Section 22
//greenBalloonBumper_mc (greenBalloonBumper_mc)
package {
	import flash.display.*;

	public dynamic class greenBalloonBumper_mc extends MovieClip {

	}
}//package 
Section 23
//greenTopBumper_mc (greenTopBumper_mc)
package {
	import flash.display.*;

	public dynamic class greenTopBumper_mc extends MovieClip {

	}
}//package 
Section 24
//inflateLight_mc (inflateLight_mc)
package {
	import flash.display.*;

	public dynamic class inflateLight_mc extends MovieClip {

	}
}//package 
Section 25
//launcher_mc (launcher_mc)
package {
	import flash.display.*;

	public dynamic class launcher_mc extends MovieClip {

	}
}//package 
Section 26
//leftCenter_mc (leftCenter_mc)
package {
	import flash.display.*;

	public dynamic class leftCenter_mc extends MovieClip {

	}
}//package 
Section 27
//leftCorner_mc (leftCorner_mc)
package {
	import flash.display.*;

	public dynamic class leftCorner_mc extends MovieClip {

	}
}//package 
Section 28
//lightsA_mc (lightsA_mc)
package {
	import flash.display.*;

	public dynamic class lightsA_mc extends MovieClip {

	}
}//package 
Section 29
//partyEntrance_mc (partyEntrance_mc)
package {
	import flash.display.*;

	public dynamic class partyEntrance_mc extends MovieClip {

	}
}//package 
Section 30
//redBalloonBumper_mc (redBalloonBumper_mc)
package {
	import flash.display.*;

	public dynamic class redBalloonBumper_mc extends MovieClip {

	}
}//package 
Section 31
//redTopBumper_mc (redTopBumper_mc)
package {
	import flash.display.*;

	public dynamic class redTopBumper_mc extends MovieClip {

	}
}//package 
Section 32
//Reshiram (Reshiram)
package {
	import flash.display.*;

	public dynamic class Reshiram extends MovieClip {

		public var leg1:MovieClip;
		public var leg2:MovieClip;
		public var tail:MovieClip;
		public var neck:MovieClip;
		public var wing2:MovieClip;
		public var wing1:MovieClip;
		public var body:MovieClip;
		public var belly:MovieClip;
		public var head:MovieClip;
		public var leg1b:MovieClip;
		public var hair:MovieClip;

	}
}//package 
Section 33
//rightCenter_mc (rightCenter_mc)
package {
	import flash.display.*;

	public dynamic class rightCenter_mc extends MovieClip {

	}
}//package 
Section 34
//rightCorner_mc (rightCorner_mc)
package {
	import flash.display.*;

	public dynamic class rightCorner_mc extends MovieClip {

	}
}//package 
Section 35
//sideHole_mc (sideHole_mc)
package {
	import flash.display.*;

	public dynamic class sideHole_mc extends MovieClip {

	}
}//package 
Section 36
//star_mc (star_mc)
package {
	import flash.display.*;

	public dynamic class star_mc extends MovieClip {

	}
}//package 
Section 37
//tableBack (tableBack)
package {
	import flash.display.*;

	public dynamic class tableBack extends MovieClip {

	}
}//package 
Section 38
//targetA_mc (targetA_mc)
package {
	import flash.display.*;

	public dynamic class targetA_mc extends MovieClip {

	}
}//package 
Section 39
//targetASquare_mc (targetASquare_mc)
package {
	import flash.display.*;

	public dynamic class targetASquare_mc extends MovieClip {

	}
}//package 
Section 40
//targetB_mc (targetB_mc)
package {
	import flash.display.*;

	public dynamic class targetB_mc extends MovieClip {

	}
}//package 
Section 41
//targetBCircle_mc (targetBCircle_mc)
package {
	import flash.display.*;

	public dynamic class targetBCircle_mc extends MovieClip {

	}
}//package 
Section 42
//thickBar_mc (thickBar_mc)
package {
	import flash.display.*;

	public dynamic class thickBar_mc extends MovieClip {

	}
}//package 
Section 43
//thinBar_mc (thinBar_mc)
package {
	import flash.display.*;

	public dynamic class thinBar_mc extends MovieClip {

	}
}//package 
Section 44
//topBell_mc (topBell_mc)
package {
	import flash.display.*;

	public dynamic class topBell_mc extends MovieClip {

	}
}//package 
Section 45
//triangleLeft_mc (triangleLeft_mc)
package {
	import flash.display.*;

	public dynamic class triangleLeft_mc extends MovieClip {

	}
}//package 
Section 46
//triangleRight_mc (triangleRight_mc)
package {
	import flash.display.*;

	public dynamic class triangleRight_mc extends MovieClip {

	}
}//package 
Section 47
//warp_mc (warp_mc)
package {
	import flash.display.*;

	public dynamic class warp_mc extends MovieClip {

	}
}//package
Library Items
Symbol 1 Graphic	Used by:66
Symbol 2 Graphic	Used by:3
Symbol 3 MovieClip	Uses:2	Used by:66
Symbol 4 Graphic	Used by:5
Symbol 5 MovieClip	Uses:4	Used by:66
Symbol 6 Graphic	Used by:7
Symbol 7 MovieClip	Uses:6	Used by:66
Symbol 8 Graphic	Used by:12
Symbol 9 Font	Used by:10 113 114
Symbol 10 Text	Uses:9	Used by:12
Symbol 11 Graphic	Used by:12
Symbol 12 MovieClip	Uses:8 10 11	Used by:66
Symbol 13 Graphic	Used by:14
Symbol 14 MovieClip	Uses:13	Used by:66
Symbol 15 Graphic	Used by:16
Symbol 16 MovieClip	Uses:15	Used by:66
Symbol 17 Graphic	Used by:18
Symbol 18 MovieClip	Uses:17	Used by:66
Symbol 19 Graphic	Used by:24
Symbol 20 Graphic	Used by:21
Symbol 21 MovieClip	Uses:20	Used by:24
Symbol 22 Graphic	Used by:23
Symbol 23 MovieClip	Uses:22	Used by:24
Symbol 24 MovieClip {game_fla.head_55}	Uses:19 21 23	Used by:66
Symbol 25 Graphic	Used by:26
Symbol 26 MovieClip	Uses:25	Used by:66
Symbol 27 Graphic	Used by:28
Symbol 28 MovieClip	Uses:27	Used by:66
Symbol 29 ShapeTweening	Used by:63
Symbol 30 ShapeTweening	Used by:63
Symbol 31 Graphic	Used by:63
Symbol 32 Graphic	Used by:33
Symbol 33 MovieClip	Uses:32	Used by:63
Symbol 34 Graphic	Used by:35
Symbol 35 MovieClip	Uses:34	Used by:63
Symbol 36 Graphic	Used by:37
Symbol 37 MovieClip	Uses:36	Used by:63
Symbol 38 ShapeTweening	Used by:63
Symbol 39 ShapeTweening	Used by:63
Symbol 40 ShapeTweening	Used by:63
Symbol 41 Graphic	Used by:63
Symbol 42 ShapeTweening	Used by:63
Symbol 43 ShapeTweening	Used by:63
Symbol 44 ShapeTweening	Used by:63
Symbol 45 ShapeTweening	Used by:63
Symbol 46 Graphic	Used by:63
Symbol 47 ShapeTweening	Used by:63
Symbol 48 ShapeTweening	Used by:63
Symbol 49 Graphic	Used by:63
Symbol 50 ShapeTweening	Used by:63
Symbol 51 ShapeTweening	Used by:63
Symbol 52 ShapeTweening	Used by:63
Symbol 53 Graphic	Used by:63
Symbol 54 ShapeTweening	Used by:63
Symbol 55 ShapeTweening	Used by:63
Symbol 56 ShapeTweening	Used by:63
Symbol 57 Graphic	Used by:63
Symbol 58 ShapeTweening	Used by:63
Symbol 59 ShapeTweening	Used by:63
Symbol 60 ShapeTweening	Used by:63
Symbol 61 Graphic	Used by:63
Symbol 62 Graphic	Used by:63
Symbol 63 MovieClip {game_fla.belly_60}	Uses:29 30 31 33 35 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62	Used by:66
Symbol 64 Font	Used by:65 198 200 201 202 203 205
Symbol 65 Text	Uses:64	Used by:66
Symbol 66 MovieClip {Reshiram}	Uses:1 3 5 7 12 14 16 18 24 26 28 63 65
Symbol 67 Graphic	Used by:68
Symbol 68 MovieClip {ballClip}	Uses:67
Symbol 69 Graphic	Used by:71
Symbol 70 Graphic	Used by:71
Symbol 71 MovieClip {redBalloonBumper_mc}	Uses:69 70
Symbol 72 Graphic	Used by:74
Symbol 73 Graphic	Used by:74
Symbol 74 MovieClip {blueBalloonBumper_mc}	Uses:72 73
Symbol 75 Graphic	Used by:77
Symbol 76 Graphic	Used by:77
Symbol 77 MovieClip {greenBalloonBumper_mc}	Uses:75 76
Symbol 78 Graphic	Used by:80
Symbol 79 Graphic	Used by:80
Symbol 80 MovieClip {redTopBumper_mc}	Uses:78 79
Symbol 81 Graphic	Used by:93
Symbol 82 ShapeTweening	Used by:87
Symbol 83 Graphic	Used by:87
Symbol 84 Graphic	Used by:87
Symbol 85 ShapeTweening	Used by:87
Symbol 86 Graphic	Used by:87
Symbol 87 MovieClip	Uses:82 83 84 85 86	Used by:93
Symbol 88 Graphic	Used by:89
Symbol 89 MovieClip	Uses:88	Used by:93
Symbol 90 Graphic	Used by:93
Symbol 91 Graphic	Used by:93
Symbol 92 Graphic	Used by:93
Symbol 93 MovieClip {AmberInflateClip}	Uses:81 87 89 90 91 92	Used by:Timeline
Symbol 94 Graphic	Used by:95
Symbol 95 MovieClip {targetASquare_mc}	Uses:94	Used by:Timeline
Symbol 96 Graphic	Used by:98
Symbol 97 Graphic	Used by:98
Symbol 98 MovieClip {inflateLight_mc}	Uses:96 97	Used by:Timeline
Symbol 99 Graphic	Used by:101 167
Symbol 100 Graphic	Used by:101
Symbol 101 MovieClip {caveLight_mc}	Uses:99 100	Used by:Timeline
Symbol 102 Graphic	Used by:109
Symbol 103 Graphic	Used by:109
Symbol 104 Graphic	Used by:109
Symbol 105 Graphic	Used by:109
Symbol 106 Graphic	Used by:109
Symbol 107 Graphic	Used by:109
Symbol 108 Graphic	Used by:109
Symbol 109 MovieClip {targetBCircle_mc}	Uses:102 103 104 105 106 107 108	Used by:Timeline
Symbol 110 Graphic	Used by:117
Symbol 111 Graphic	Used by:112
Symbol 112 MovieClip	Uses:111	Used by:117
Symbol 113 Text	Uses:9	Used by:117
Symbol 114 Text	Uses:9	Used by:117
Symbol 115 Graphic	Used by:117
Symbol 116 Graphic	Used by:117
Symbol 117 MovieClip {AmberCatchClip}	Uses:110 112 113 114 115 116	Used by:Timeline
Symbol 118 Graphic	Used by:120
Symbol 119 Graphic	Used by:120
Symbol 120 MovieClip {topBell_mc}	Uses:118 119	Used by:Timeline
Symbol 121 Graphic	Used by:123
Symbol 122 Graphic	Used by:123
Symbol 123 MovieClip {bell_mc}	Uses:121 122	Used by:Timeline
Symbol 124 Graphic	Used by:125
Symbol 125 MovieClip {sideHole_mc}	Uses:124	Used by:Timeline
Symbol 126 Graphic	Used by:127
Symbol 127 MovieClip {warp_mc}	Uses:126	Used by:Timeline
Symbol 128 Graphic	Used by:129
Symbol 129 MovieClip {goldBumper_mc}	Uses:128	Used by:Timeline
Symbol 130 Graphic	Used by:135
Symbol 131 Graphic	Used by:135
Symbol 132 Graphic	Used by:135
Symbol 133 Graphic	Used by:135
Symbol 134 Graphic	Used by:135
Symbol 135 MovieClip {launcher_mc}	Uses:130 131 132 133 134	Used by:Timeline
Symbol 136 Graphic	Used by:137
Symbol 137 MovieClip {star_mc}	Uses:136	Used by:Timeline
Symbol 138 Graphic	Used by:139
Symbol 139 MovieClip {bouncyLeft_mc}	Uses:138	Used by:Timeline
Symbol 140 Graphic	Used by:141
Symbol 141 MovieClip {bouncyRight_mc}	Uses:140	Used by:Timeline
Symbol 142 Graphic	Used by:143
Symbol 143 MovieClip {bouncySwitch_mc}	Uses:142	Used by:Timeline
Symbol 144 Graphic	Used by:146
Symbol 145 Graphic	Used by:146
Symbol 146 MovieClip {barrier_mc}	Uses:144 145	Used by:Timeline
Symbol 147 Graphic	Used by:151
Symbol 148 Graphic	Used by:151
Symbol 149 Graphic	Used by:151
Symbol 150 Graphic	Used by:151
Symbol 151 MovieClip {entranceDoor_mc}	Uses:147 148 149 150	Used by:Timeline
Symbol 152 Graphic	Used by:153
Symbol 153 MovieClip {targetB_mc}	Uses:152	Used by:Timeline
Symbol 154 Graphic	Used by:155
Symbol 155 MovieClip {targetA_mc}	Uses:154	Used by:Timeline
Symbol 156 Graphic	Used by:158
Symbol 157 Graphic	Used by:158
Symbol 158 MovieClip {blueTopBumper_mc}	Uses:156 157	Used by:Timeline
Symbol 159 Graphic	Used by:161
Symbol 160 Graphic	Used by:161
Symbol 161 MovieClip {greenTopBumper_mc}	Uses:159 160	Used by:Timeline
Symbol 162 Graphic	Used by:163
Symbol 163 MovieClip {triangleRight_mc}	Uses:162	Used by:Timeline
Symbol 164 Graphic	Used by:165
Symbol 165 MovieClip {triangleLeft_mc}	Uses:164	Used by:Timeline
Symbol 166 Graphic	Used by:167
Symbol 167 MovieClip {lightsA_mc}	Uses:99 166	Used by:Timeline
Symbol 168 Graphic	Used by:172
Symbol 169 Graphic	Used by:172
Symbol 170 Graphic	Used by:172
Symbol 171 Graphic	Used by:172 176
Symbol 172 MovieClip {flipperLeft_mc}	Uses:168 169 170 171	Used by:Timeline
Symbol 173 Graphic	Used by:176
Symbol 174 Graphic	Used by:176
Symbol 175 Graphic	Used by:176
Symbol 176 MovieClip {flipperRight_mc}	Uses:173 174 175 171	Used by:Timeline
Symbol 177 Graphic	Used by:178
Symbol 178 MovieClip {thinBar_mc}	Uses:177	Used by:Timeline
Symbol 179 Graphic	Used by:180
Symbol 180 MovieClip {thickBar_mc}	Uses:179	Used by:Timeline
Symbol 181 Graphic	Used by:182
Symbol 182 MovieClip {rightCorner_mc}	Uses:181	Used by:Timeline
Symbol 183 Graphic	Used by:184
Symbol 184 MovieClip {partyEntrance_mc}	Uses:183	Used by:Timeline
Symbol 185 Graphic	Used by:186
Symbol 186 MovieClip {leftCorner_mc}	Uses:185	Used by:Timeline
Symbol 187 Graphic	Used by:188
Symbol 188 MovieClip {leftCenter_mc}	Uses:187	Used by:Timeline
Symbol 189 Graphic	Used by:190
Symbol 190 MovieClip {gemRight_mc}	Uses:189	Used by:Timeline
Symbol 191 Graphic	Used by:192
Symbol 192 MovieClip {gemLeft_mc}	Uses:191	Used by:Timeline
Symbol 193 Graphic	Used by:194
Symbol 194 MovieClip {rightCenter_mc}	Uses:193	Used by:Timeline
Symbol 195 Graphic	Used by:196
Symbol 196 MovieClip {tableBack}	Uses:195	Used by:Timeline
Symbol 197 Font	Used by:198 206
Symbol 198 Text	Uses:197 64	Used by:Timeline
Symbol 199 Graphic	Used by:207
Symbol 200 Text	Uses:64	Used by:207
Symbol 201 Text	Uses:64	Used by:207
Symbol 202 Text	Uses:64	Used by:207
Symbol 203 Text	Uses:64	Used by:207
Symbol 204 Graphic	Used by:207
Symbol 205 Text	Uses:64	Used by:207
Symbol 206 Text	Uses:197	Used by:207
Symbol 207 MovieClip	Uses:199 200 201 202 203 204 205 206	Used by:Timeline
Instance Names
"board"	Frame 2	Symbol 196 MovieClip {tableBack}
"eye"	Symbol 24 MovieClip {game_fla.head_55} Frame 1	Symbol 21 MovieClip
"mouth"	Symbol 24 MovieClip {game_fla.head_55} Frame 1	Symbol 23 MovieClip
"fur1"	Symbol 63 MovieClip {game_fla.belly_60} Frame 1	Symbol 33 MovieClip
"fur2"	Symbol 63 MovieClip {game_fla.belly_60} Frame 1	Symbol 35 MovieClip
"fur3"	Symbol 63 MovieClip {game_fla.belly_60} Frame 1	Symbol 37 MovieClip
"hair"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 3 MovieClip
"wing2"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 5 MovieClip
"leg2"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 7 MovieClip
"tail"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 12 MovieClip
"leg1b"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 14 MovieClip
"neck"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 16 MovieClip
"body"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 18 MovieClip
"head"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 24 MovieClip {game_fla.head_55}
"wing1"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 26 MovieClip
"leg1"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 28 MovieClip
"belly"	Symbol 66 MovieClip {Reshiram} Frame 1	Symbol 63 MovieClip {game_fla.belly_60}
"belly1"	Symbol 93 MovieClip {AmberInflateClip} Frame 1	Symbol 87 MovieClip
"belly2"	Symbol 93 MovieClip {AmberInflateClip} Frame 1	Symbol 89 MovieClip
"ball"	Symbol 117 MovieClip {AmberCatchClip} Frame 1	Symbol 112 MovieClip
Special Tags
FileAttributes (69)
Timeline Frame 1
Access local files only, Metadata not present, AS3.