Section 1
//BallBody_15 (Aquarius_fla.BallBody_15)
package Aquarius_fla {
	import flash.display.*;

	public dynamic class BallBody_15 extends MovieClip {

		public function BallBody_15(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

	}
}//package Aquarius_fla 
Section 2
//LevelCountDown_8 (Aquarius_fla.LevelCountDown_8)
package Aquarius_fla {
	import flash.display.*;
	import flash.text.*;

	public dynamic class LevelCountDown_8 extends MovieClip {

		public var txtLevel:TextField;
		public var txtLevelLabel:TextField;

		public function LevelCountDown_8(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

	}
}//package Aquarius_fla 
Section 3
//MusicButton_7 (Aquarius_fla.MusicButton_7)
package Aquarius_fla {
	import flash.display.*;

	public dynamic class MusicButton_7 extends MovieClip {

		public function MusicButton_7(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

	}
}//package Aquarius_fla 
Section 4
//SoundButton_5 (Aquarius_fla.SoundButton_5)
package Aquarius_fla {
	import flash.display.*;

	public dynamic class SoundButton_5 extends MovieClip {

		public function SoundButton_5(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

	}
}//package Aquarius_fla 
Section 5
//Elastic (fl.transitions.easing.Elastic)
package fl.transitions.easing {

	public class Elastic {

		public static function easeIn(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number=0, _arg6:Number=0):Number{
			var _local7:Number;
			if (_arg1 == 0){
				return (_arg2);
			};
			_arg1 = (_arg1 / _arg4);
			if (_arg1 == 1){
				return ((_arg2 + _arg3));
			};
			if (!_arg6){
				_arg6 = (_arg4 * 0.3);
			};
			if (((!(_arg5)) || ((_arg5 < Math.abs(_arg3))))){
				_arg5 = _arg3;
				_local7 = (_arg6 / 4);
			} else {
				_local7 = ((_arg6 / (2 * Math.PI)) * Math.asin((_arg3 / _arg5)));
			};
			--_arg1;
			return ((-(((_arg5 * Math.pow(2, (10 * _arg1))) * Math.sin(((((_arg1 * _arg4) - _local7) * (2 * Math.PI)) / _arg6)))) + _arg2));
		}
		public static function easeOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number=0, _arg6:Number=0):Number{
			var _local7:Number;
			if (_arg1 == 0){
				return (_arg2);
			};
			_arg1 = (_arg1 / _arg4);
			if (_arg1 == 1){
				return ((_arg2 + _arg3));
			};
			if (!_arg6){
				_arg6 = (_arg4 * 0.3);
			};
			if (((!(_arg5)) || ((_arg5 < Math.abs(_arg3))))){
				_arg5 = _arg3;
				_local7 = (_arg6 / 4);
			} else {
				_local7 = ((_arg6 / (2 * Math.PI)) * Math.asin((_arg3 / _arg5)));
			};
			return (((((_arg5 * Math.pow(2, (-10 * _arg1))) * Math.sin(((((_arg1 * _arg4) - _local7) * (2 * Math.PI)) / _arg6))) + _arg3) + _arg2));
		}
		public static function easeInOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number=0, _arg6:Number=0):Number{
			var _local7:Number;
			if (_arg1 == 0){
				return (_arg2);
			};
			_arg1 = (_arg1 / (_arg4 / 2));
			if (_arg1 == 2){
				return ((_arg2 + _arg3));
			};
			if (!_arg6){
				_arg6 = (_arg4 * (0.3 * 1.5));
			};
			if (((!(_arg5)) || ((_arg5 < Math.abs(_arg3))))){
				_arg5 = _arg3;
				_local7 = (_arg6 / 4);
			} else {
				_local7 = ((_arg6 / (2 * Math.PI)) * Math.asin((_arg3 / _arg5)));
			};
			if (_arg1 < 1){
				--_arg1;
				return (((-0.5 * ((_arg5 * Math.pow(2, (10 * _arg1))) * Math.sin(((((_arg1 * _arg4) - _local7) * (2 * Math.PI)) / _arg6)))) + _arg2));
			};
			--_arg1;
			return ((((((_arg5 * Math.pow(2, (-10 * _arg1))) * Math.sin(((((_arg1 * _arg4) - _local7) * (2 * Math.PI)) / _arg6))) * 0.5) + _arg3) + _arg2));
		}

	}
}//package fl.transitions.easing 
Section 6
//Strong (fl.transitions.easing.Strong)
package fl.transitions.easing {

	public class Strong {

		public static function easeIn(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			_arg1 = (_arg1 / _arg4);
			return (((((((_arg3 * _arg1) * _arg1) * _arg1) * _arg1) * _arg1) + _arg2));
		}
		public static function easeOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			_arg1 = ((_arg1 / _arg4) - 1);
			return (((_arg3 * (((((_arg1 * _arg1) * _arg1) * _arg1) * _arg1) + 1)) + _arg2));
		}
		public static function easeInOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			_arg1 = (_arg1 / (_arg4 / 2));
			if (_arg1 < 1){
				return ((((((((_arg3 / 2) * _arg1) * _arg1) * _arg1) * _arg1) * _arg1) + _arg2));
			};
			_arg1 = (_arg1 - 2);
			return ((((_arg3 / 2) * (((((_arg1 * _arg1) * _arg1) * _arg1) * _arg1) + 2)) + _arg2));
		}

	}
}//package fl.transitions.easing 
Section 7
//Tween (fl.transitions.Tween)
package fl.transitions {
	import flash.display.*;
	import flash.events.*;
	import flash.utils.*;

	public class Tween extends EventDispatcher {

		public var isPlaying:Boolean;// = false
		public var obj:Object;// = null
		public var prop:String;// = ""
		public var func:Function;
		public var begin:Number;// = NAN
		public var change:Number;// = NAN
		public var useSeconds:Boolean;// = false
		public var prevTime:Number;// = NAN
		public var prevPos:Number;// = NAN
		public var looping:Boolean;// = false
		private var _duration:Number;// = NAN
		private var _time:Number;// = NAN
		private var _fps:Number;// = NAN
		private var _position:Number;// = NAN
		private var _startTime:Number;// = NAN
		private var _intervalID:uint;// = 0
		private var _finish:Number;// = NAN
		private var _timer:Timer;// = null

		protected static var _mc:MovieClip = new MovieClip();

		public function Tween(_arg1:Object, _arg2:String, _arg3:Function, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Boolean=false){
			this.func = function (_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
				return ((((_arg3 * _arg1) / _arg4) + _arg2));
			};
			super();
			if (!arguments.length){
				return;
			};
			this.obj = _arg1;
			this.prop = _arg2;
			this.begin = _arg4;
			this.position = _arg4;
			this.duration = _arg6;
			this.useSeconds = _arg7;
			if ((_arg3 is Function)){
				this.func = _arg3;
			};
			this.finish = _arg5;
			this._timer = new Timer(100);
			this.start();
		}
		public function get time():Number{
			return (this._time);
		}
		public function set time(_arg1:Number):void{
			this.prevTime = this._time;
			if (_arg1 > this.duration){
				if (this.looping){
					this.rewind((_arg1 - this._duration));
					this.update();
					this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_LOOP, this._time, this._position));
				} else {
					if (this.useSeconds){
						this._time = this._duration;
						this.update();
					};
					this.stop();
					this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_FINISH, this._time, this._position));
				};
			} else {
				if (_arg1 < 0){
					this.rewind();
					this.update();
				} else {
					this._time = _arg1;
					this.update();
				};
			};
		}
		public function get duration():Number{
			return (this._duration);
		}
		public function set duration(_arg1:Number):void{
			this._duration = ((_arg1)<=0) ? Infinity : _arg1;
		}
		public function get FPS():Number{
			return (this._fps);
		}
		public function set FPS(_arg1:Number):void{
			var _local2:Boolean = this.isPlaying;
			this.stopEnterFrame();
			this._fps = _arg1;
			if (_local2){
				this.startEnterFrame();
			};
		}
		public function get position():Number{
			return (this.getPosition(this._time));
		}
		public function set position(_arg1:Number):void{
			this.setPosition(_arg1);
		}
		public function getPosition(_arg1:Number=NaN):Number{
			if (isNaN(_arg1)){
				_arg1 = this._time;
			};
			return (this.func(_arg1, this.begin, this.change, this._duration));
		}
		public function setPosition(_arg1:Number):void{
			this.prevPos = this._position;
			if (this.prop.length){
				this.obj[this.prop] = (this._position = _arg1);
			};
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_CHANGE, this._time, this._position));
		}
		public function get finish():Number{
			return ((this.begin + this.change));
		}
		public function set finish(_arg1:Number):void{
			this.change = (_arg1 - this.begin);
		}
		public function continueTo(_arg1:Number, _arg2:Number):void{
			this.begin = this.position;
			this.finish = _arg1;
			if (!isNaN(_arg2)){
				this.duration = _arg2;
			};
			this.start();
		}
		public function yoyo():void{
			this.continueTo(this.begin, this.time);
		}
		protected function startEnterFrame():void{
			var _local1:Number;
			if (isNaN(this._fps)){
				_mc.addEventListener(Event.ENTER_FRAME, this.onEnterFrame, false, 0, true);
			} else {
				_local1 = (1000 / this._fps);
				this._timer.delay = _local1;
				this._timer.addEventListener(TimerEvent.TIMER, this.timerHandler, false, 0, true);
				this._timer.start();
			};
			this.isPlaying = true;
		}
		protected function stopEnterFrame():void{
			if (isNaN(this._fps)){
				_mc.removeEventListener(Event.ENTER_FRAME, this.onEnterFrame);
			} else {
				this._timer.stop();
			};
			this.isPlaying = false;
		}
		public function start():void{
			this.rewind();
			this.startEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_START, this._time, this._position));
		}
		public function stop():void{
			this.stopEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_STOP, this._time, this._position));
		}
		public function resume():void{
			this.fixTime();
			this.startEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_RESUME, this._time, this._position));
		}
		public function rewind(_arg1:Number=0):void{
			this._time = _arg1;
			this.fixTime();
			this.update();
		}
		public function fforward():void{
			this.time = this._duration;
			this.fixTime();
		}
		public function nextFrame():void{
			if (this.useSeconds){
				this.time = ((getTimer() - this._startTime) / 1000);
			} else {
				this.time = (this._time + 1);
			};
		}
		protected function onEnterFrame(_arg1:Event):void{
			this.nextFrame();
		}
		protected function timerHandler(_arg1:TimerEvent):void{
			this.nextFrame();
			_arg1.updateAfterEvent();
		}
		public function prevFrame():void{
			if (!this.useSeconds){
				this.time = (this._time - 1);
			};
		}
		private function fixTime():void{
			if (this.useSeconds){
				this._startTime = (getTimer() - (this._time * 1000));
			};
		}
		private function update():void{
			this.setPosition(this.getPosition(this._time));
		}

	}
}//package fl.transitions 
Section 8
//TweenEvent (fl.transitions.TweenEvent)
package fl.transitions {
	import flash.events.*;

	public class TweenEvent extends Event {

		public var time:Number;// = NAN
		public var position:Number;// = NAN

		public static const MOTION_START:String = "motionStart";
		public static const MOTION_STOP:String = "motionStop";
		public static const MOTION_FINISH:String = "motionFinish";
		public static const MOTION_CHANGE:String = "motionChange";
		public static const MOTION_RESUME:String = "motionResume";
		public static const MOTION_LOOP:String = "motionLoop";

		public function TweenEvent(_arg1:String, _arg2:Number, _arg3:Number, _arg4:Boolean=false, _arg5:Boolean=false){
			super(_arg1, _arg4, _arg5);
			this.time = _arg2;
			this.position = _arg3;
		}
		override public function clone():Event{
			return (new TweenEvent(this.type, this.time, this.position, this.bubbles, this.cancelable));
		}

	}
}//package fl.transitions 
Section 9
//gameOver (sound.gameOver)
package sound {
	import flash.media.*;

	public dynamic class gameOver extends Sound {

	}
}//package sound 
Section 10
//levelOver (sound.levelOver)
package sound {
	import flash.media.*;

	public dynamic class levelOver extends Sound {

	}
}//package sound 
Section 11
//loop (sound.loop)
package sound {
	import flash.media.*;

	public dynamic class loop extends Sound {

	}
}//package sound 
Section 12
//sfx0 (sound.sfx0)
package sound {
	import flash.media.*;

	public dynamic class sfx0 extends Sound {

	}
}//package sound 
Section 13
//sfx1 (sound.sfx1)
package sound {
	import flash.media.*;

	public dynamic class sfx1 extends Sound {

	}
}//package sound 
Section 14
//sfx2 (sound.sfx2)
package sound {
	import flash.media.*;

	public dynamic class sfx2 extends Sound {

	}
}//package sound 
Section 15
//sfx3 (sound.sfx3)
package sound {
	import flash.media.*;

	public dynamic class sfx3 extends Sound {

	}
}//package sound 
Section 16
//sfx4 (sound.sfx4)
package sound {
	import flash.media.*;

	public dynamic class sfx4 extends Sound {

	}
}//package sound 
Section 17
//sfx5 (sound.sfx5)
package sound {
	import flash.media.*;

	public dynamic class sfx5 extends Sound {

	}
}//package sound 
Section 18
//sfx6 (sound.sfx6)
package sound {
	import flash.media.*;

	public dynamic class sfx6 extends Sound {

	}
}//package sound 
Section 19
//sfx7 (sound.sfx7)
package sound {
	import flash.media.*;

	public dynamic class sfx7 extends Sound {

	}
}//package sound 
Section 20
//Communicator (src.comm.Communicator)
package src.comm {
	import flash.system.*;

	public class Communicator {

		private var hasSentGameStart;// = false
		private var hasSentGameEnd;// = false
		private var hasSentGameOver;// = false
		private var hasSentLastTick;// = false

		private static var CMD_START_ROUND = 751;
		private static var CMD_GAME_CLICKED = 968;
		private static var CMD_LAST_TICK = 225;

		public function Communicator(){
			super();
		}
		public function gameStarted(){
			trace("GAME START");
			if (!hasSentGameStart){
				hasSentGameStart = true;
				fscommand("gameStart");
			};
		}
		public function gameEnd(score){
			trace("GAME ENDS");
			if (!hasSentGameEnd){
				hasSentGameEnd = true;
				fscommand("gameEnd", score);
			};
		}
		public function gameQuit(){
			trace("GAME QUIT");
			if (!hasSentGameOver){
				hasSentGameOver = true;
				fscommand("gameQuit");
			};
		}
		public function gameClicked(tick, theX, theY){
			fscommand("playData", ((((((CMD_GAME_CLICKED + ",") + tick) + " ") + theX) + " ") + theY));
		}
		public function startRound(tick){
			fscommand("playData", ((CMD_START_ROUND + ",") + tick));
		}
		public function lastTick(tick, noOfRnd, musicOn, sfxOn){
			if (!hasSentLastTick){
				fscommand("playData", ((((((((CMD_LAST_TICK + ",") + tick) + " ") + noOfRnd) + " ") + musicOn) + " ") + sfxOn));
				hasSentLastTick = true;
			};
		}

	}
}//package src.comm 
Section 21
//GameDataParser (src.comm.GameDataParser)
package src.comm {
	import flash.xml.*;

	public class GameDataParser {

		public static var textMappings:Object;
		public static var levelData:Object;
		public static var records:Object;
		public static var sounds:Object;

		public static function parseGameData(gameData:String):Object{
			var result:Object = new Object();
			var gameDataXml:XMLDocument = new XMLDocument(gameData);
			textMappings = new Object();
			records = new Object();
			levelData = new Object();
			result.textMappings = textMappings;
			result.records = records;
			result.levelData = levelData;
			var cn:* = gameDataXml.firstChild.childNodes;
			records = new Object();
			result.records = records;
			sounds = new Object();
			var randomSeed:int = parseInt(gameDataXml.firstChild.attributes.randomseed);
			result.randomSeed = randomSeed;
			var animationData:String = "";
			var i:* = 0;
			while (i < cn.length) {
				if (cn[i].nodeName == "id"){
				};
				if (cn[i].nodeName == "game"){
					result.gameType = new String(cn[i].attributes.type);
				};
				if (cn[i].nodeName == "userType"){
					result.userType = new String(cn[i].firstChild.nodeValue);
				};
				if (cn[i].nodeName == "text"){
					if ((((cn[i].firstChild == null)) || ((cn[i].firstChild == undefined)))){
						textMappings[cn[i].attributes.id] = (("[" + cn[i].attributes.id) + "]");
					} else {
						textMappings[cn[i].attributes.id] = new String(cn[i].firstChild.nodeValue);
					};
				};
				if (cn[i].nodeName == "record"){
					if ((((cn[i].firstChild == null)) || ((cn[i].firstChild == undefined)))){
						records[cn[i].attributes.id] = (("[" + cn[i].attributes.id) + "]");
					} else {
						records[cn[i].attributes.id] = new Number(cn[i].firstChild.nodeValue);
					};
				};
				if (cn[i].nodeName == "sounds"){
					if ((((cn[i].firstChild == null)) || ((cn[i].firstChild == undefined)))){
						sounds[cn[i].attributes.id] = (("[" + cn[i].attributes.id) + "]");
					} else {
						sounds[cn[i].attributes.id] = new String(cn[i].firstChild.nodeValue);
					};
				};
				if (cn[i].nodeName == "unlock"){
					animationData = (animationData + (((new String(cn[i].attributes.id) + ",") + new String(cn[i].firstChild.nodeValue)) + "-"));
				};
				i++;
			};
			result.sounds = sounds;
			result.animationData = animationData;
			return (result);
		}

	}
}//package src.comm 
Section 22
//MtRandom (src.math.MtRandom)
package src.math {
	import flash.utils.*;

	public class MtRandom {

		private var mt:Array;
		private var mti:uint;

		public static var N:int = 624;
		public static var M:int = 397;
		public static var MATRIX_A:uint = 2567483615;
		public static var UPPER_MASK:uint = 2147483648;
		public static var LOWER_MASK:uint = 2147483647;
		private static var mag01:Array = [uint(0), uint(MATRIX_A)];

		public function MtRandom(seed:uint=0){
			mti = (N + 1);
			super();
			if (seed == 0){
				seed = getTimer();
			};
			mt = new Array(N);
			init_genrand(seed);
		}
		public function setSeed(seed:uint):void{
			init_genrand(seed);
		}
		public function nextInt(n:uint):uint{
			return (((genrand_int32() & 2147483647) % n));
		}
		public function nextFloat():Number{
			return ((next(24) / 16777216));
		}
		public function nextDouble():Number{
			return ((next(24) / 16777216));
		}
		private function next(bits:uint):uint{
			return ((genrand_int32() & ((uint(1) << bits) - uint(1))));
		}
		private function init_genrand(s:uint){
			var v0:uint;
			var v1:uint;
			mt[0] = uint(s);
			mti = 1;
			while (mti < N) {
				v0 = (mt[(mti - 1)] ^ (mt[(mti - 1)] >>> 30));
				v1 = uint((v0 * 1289));
				v1 = uint((v1 * 1406077));
				v1 = uint((v1 + mti));
				mt[mti] = v1;
				mti++;
			};
		}
		private function genrand_int32():uint{
			var y:Number;
			var kk:uint;
			if (mti >= N){
				if (mti == (N + 1)){
					init_genrand(5489);
				};
				kk = 0;
				while (kk < (N - M)) {
					y = ((mt[kk] & UPPER_MASK) | (mt[(kk + 1)] & LOWER_MASK));
					mt[kk] = ((mt[(kk + M)] ^ (y >>> 1)) ^ mag01[uint((y & 1))]);
					kk++;
				};
				while (kk < (N - 1)) {
					y = ((mt[kk] & UPPER_MASK) | (mt[(kk + 1)] & LOWER_MASK));
					mt[kk] = ((mt[(kk + (M - N))] ^ (y >>> 1)) ^ mag01[uint((y & 1))]);
					kk++;
				};
				y = ((mt[(N - 1)] & UPPER_MASK) | (mt[0] & LOWER_MASK));
				mt[(N - 1)] = ((mt[(M - 1)] ^ (y >>> 1)) ^ mag01[uint((y & 1))]);
				mti = 0;
			};
			y = mt[mti++];
			y = (y ^ (y >>> 11));
			y = (y ^ ((y << 7) & 2636928640));
			y = (y ^ ((y << 15) & 4022730752));
			y = (y ^ (y >>> 18));
			return (uint(y));
		}

	}
}//package src.math 
Section 23
//XPMath (src.math.XPMath)
package src.math {

	public class XPMath {

		public static function atan2(y:Number, x:Number):Number{
			var at:Number;
			var pi:Number = 3.14159265358979;
			var pi2:Number = 1.5707963267949;
			if (x == 0){
				if (y > 0){
					return (pi2);
				};
				if (y == 0){
					return (0);
				};
				return (-(pi2));
			};
			var z:Number = (y / x);
			if (Math.abs(z) < 1){
				at = (z / (1 + ((0.28 * z) * z)));
				if (x < 0){
					if (y < 0){
						return ((at - pi));
					};
					return ((at + pi));
				};
			} else {
				at = (pi2 - (z / ((z * z) + 0.28)));
				if (y < 0){
					return ((at - pi));
				};
			};
			return (at);
		}
		public static function cos(f:Number):Number{
			var i1:int;
			var x:Number = ((f > 0)) ? f : -(f);
			var pi2:Number = 1.5707963267949;
			if (x >= (12.5663706143592 + pi2)){
				i1 = int((x * 0.636619772367581));
				if ((i1 & 1) != 0){
					i1++;
				};
				x = (x - (i1 * pi2));
			} else {
				if (x < pi2){
				} else {
					if (x < (pi2 + 3.14159265358979)){
						x = (x - 3.14159265358979);
						i1 = 2;
					} else {
						if (x < (6.28318530717959 + pi2)){
							x = (x - 6.28318530717959);
						} else {
							if (x < (9.42477796076938 + pi2)){
								x = (x - 9.42477796076938);
								i1 = 2;
							} else {
								x = (x - 12.5663706143592);
							};
						};
					};
				};
			};
			var x2:Number = (x * x);
			var co:Number = (0.999999953027512 + (x2 * (-0.499999047777921 + (x2 * (0.041663573160188 + (x2 * (-0.0013853629536173 + (x2 * 2.31524166599385E-5))))))));
			return ((((i1 & 2))!=0) ? -(co) : co);
		}
		public static function sin(f:Number):Number{
			f = (f - 1.5707963267949);
			var i1:int;
			var x:Number = ((f > 0)) ? f : -(f);
			if (x >= (12.5663706143592 + 1.5707963267949)){
				i1 = int((x * 0.636619772367581));
				if ((i1 & 1) != 0){
					i1++;
				};
				x = (x - (i1 * 1.5707963267949));
			} else {
				if (x < 1.5707963267949){
				} else {
					if (x < (1.5707963267949 + 3.14159265358979)){
						x = (x - 3.14159265358979);
						i1 = 2;
					} else {
						if (x < (6.28318530717959 + 1.5707963267949)){
							x = (x - 6.28318530717959);
						} else {
							if (x < (9.42477796076938 + 1.5707963267949)){
								x = (x - 9.42477796076938);
								i1 = 2;
							} else {
								x = (x - 12.5663706143592);
							};
						};
					};
				};
			};
			var x2:Number = (x * x);
			var co:Number = (0.999999953027512 + (x2 * (-0.499999047777921 + (x2 * (0.041663573160188 + (x2 * (-0.0013853629536173 + (x2 * 2.31524166599385E-5))))))));
			return ((((i1 & 2))!=0) ? -(co) : co);
		}

	}
}//package src.math 
Section 24
//ManagedSound (src.sound.ManagedSound)
package src.sound {
	import flash.media.*;

	public class ManagedSound {

		private var ClassReference:Class;
		public var activeSounds:Array;
		private var manager:SoundManager;

		public function ManagedSound(manager:SoundManager, ClassReference:Class){
			activeSounds = new Array();
			super();
			this.manager = manager;
			this.ClassReference = ClassReference;
		}
		public function play(volume:Number=1, pan:Number=0):ManagedSoundChannel{
			var channel:SoundChannel = new ClassReference().play(0, 0, new SoundTransform(volume, pan));
			return (new ManagedSoundChannel(manager, this, channel));
		}
		public function loop(volume:Number=1, pan:Number=0):ManagedSoundChannel{
			var channel:SoundChannel = new ClassReference().play(0, 999999999, new SoundTransform(volume, pan));
			return (new ManagedSoundChannel(manager, this, channel));
		}
		public function stop():void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].stop();
				i++;
			};
		}
		public function setPan(pan:Number):void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].setPan(pan);
				i++;
			};
		}
		public function setVolume(volume:Number):void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].setVolume(volume);
				i++;
			};
		}
		public function fadeTo(newVolume:Number, time:Number):void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].fadeTo(newVolume, time);
				i++;
			};
		}
		public function fadeToAndStop(newVolume:Number, time:Number):void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].fadeToAndStop(newVolume, time);
				i++;
			};
		}
		public function panTo(newPan:Number, time:Number):void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].panTo(newPan, time);
				i++;
			};
		}
		public function isPlaying():Boolean{
			return ((activeSounds.length > 0));
		}
		public function update():void{
			var i:int;
			while (i < activeSounds.length) {
				activeSounds[i].update();
				i++;
			};
		}

	}
}//package src.sound 
Section 25
//ManagedSoundChannel (src.sound.ManagedSoundChannel)
package src.sound {
	import flash.events.*;
	import flash.media.*;
	import flash.utils.*;

	public class ManagedSoundChannel {

		private var sound:ManagedSound;
		private var channel:SoundChannel;
		private var manager:SoundManager;
		private var targetVolume:Number;
		private var targetPan:Number;
		private var fadeStartTime:Number;// = -1
		private var fadeEndTime:Number;// = -1
		private var fadeStartVolume:Number;// = -1
		private var fadeEndVolume:Number;// = -1
		private var panStartTime:Number;// = -1
		private var panEndTime:Number;// = -1
		private var panStartVolume:Number;// = -1
		private var panEndVolume:Number;// = -1
		private var stopAfterFade:Boolean;// = false
		private var playing:Boolean;// = true

		public function ManagedSoundChannel(manager:SoundManager, sound:ManagedSound, channel:SoundChannel){
			super();
			this.manager = manager;
			this.sound = sound;
			this.channel = channel;
			sound.activeSounds.push(this);
			if (channel == null){
				soundComplete(null);
				return;
			};
			channel.addEventListener(Event.SOUND_COMPLETE, soundComplete);
			targetVolume = channel.soundTransform.volume;
			targetPan = channel.soundTransform.pan;
			update();
		}
		public function soundComplete(e:Event):void{
			if (!playing){
				return;
			};
			sound.activeSounds.splice(sound.activeSounds.indexOf(this), 1);
			playing = false;
		}
		public function setPan(pan:Number):void{
			if (!playing){
				return;
			};
			if (channel == null){
				return;
			};
			channel.soundTransform.pan = pan;
			panStartTime = -1;
			update();
		}
		public function setVolume(volume:Number):void{
			if (!playing){
				return;
			};
			stopAfterFade = false;
			this.targetVolume = volume;
			fadeStartTime = -1;
			update();
		}
		public function stop():void{
			if (!playing){
				return;
			};
			if (channel == null){
				return;
			};
			channel.stop();
			soundComplete(null);
		}
		public function fadeTo(newVolume:Number, time:Number):void{
			if (!playing){
				return;
			};
			fadeStartVolume = Math.sqrt(targetVolume);
			fadeEndVolume = Math.sqrt(newVolume);
			fadeStartTime = getTimer();
			fadeEndTime = (getTimer() + time);
			stopAfterFade = false;
		}
		public function fadeToAndStop(newVolume:Number, time:Number):void{
			if (!playing){
				return;
			};
			fadeTo(newVolume, time);
			stopAfterFade = true;
		}
		public function panTo(newPan:Number, time:Number):void{
			if (!playing){
				return;
			};
			panStartVolume = targetPan;
			panEndVolume = newPan;
			panStartTime = getTimer();
			panEndTime = (getTimer() + time);
		}
		public function update():void{
			var t:Number;
			if (!playing){
				return;
			};
			if (fadeStartTime >= 0){
				t = ((getTimer() - fadeStartTime) / (fadeEndTime - fadeStartTime));
				if (t < 0){
					t = 0;
				};
				if (t > 1){
					t = 1;
				};
				targetVolume = (fadeStartVolume + ((fadeEndVolume - fadeStartVolume) * t));
				targetVolume = (targetVolume * targetVolume);
				if (t == 1){
					fadeStartTime = -1;
				};
				if ((((t == 1)) && (stopAfterFade))){
					stop();
				};
			};
			if (panStartTime >= 0){
				t = ((getTimer() - panStartTime) / (panEndTime - panStartTime));
				if (t < 0){
					t = 0;
				};
				if (t > 1){
					t = 1;
				};
				targetPan = (panStartVolume + ((panEndVolume - panStartVolume) * t));
				if (t == 1){
					panStartTime = -1;
				};
			};
			var volume:Number = (targetVolume * manager.volume);
			var pan:Number = targetPan;
			if (channel == null){
				return;
			};
			if (((!((volume == channel.soundTransform.volume))) || (!((pan == channel.soundTransform.pan))))){
				channel.soundTransform = new SoundTransform(volume, pan);
			};
		}
		public function isPlaying():Boolean{
			return (playing);
		}

	}
}//package src.sound 
Section 26
//SoundManager (src.sound.SoundManager)
package src.sound {
	import flash.utils.*;

	public class SoundManager {

		private var managedSoundMap:Object;
		private var managedSounds:Array;
		private var lastTime:Number;// = -1
		public var volume:Number;// = 1
		private var fadeStartTime:Number;// = -1
		private var fadeEndTime:Number;// = -1
		private var fadeStartVolume:Number;// = -1
		private var fadeEndVolume:Number;// = -1

		public function SoundManager(){
			managedSoundMap = new Object();
			managedSounds = new Array();
			super();
		}
		public function get(name:String):ManagedSound{
			var ClassReference:Class;
			if (managedSoundMap[name] == null){
				ClassReference = (getDefinitionByName(("sound." + name)) as Class);
				if (ClassReference == null){
					throw (new Error(("Failed to find sound " + name)));
				};
				managedSoundMap[name] = new ManagedSound(this, ClassReference);
				managedSounds.push(managedSoundMap[name]);
			};
			return (managedSoundMap[name]);
		}
		public function fadeTo(newVolume:Number, time:Number):void{
			fadeStartVolume = Math.sqrt(volume);
			fadeEndVolume = Math.sqrt(newVolume);
			fadeStartTime = getTimer();
			fadeEndTime = (getTimer() + time);
		}
		public function setVolume(newVolume:Number):void{
			this.volume = newVolume;
			fadeStartTime = -1;
		}
		public function stopAll():void{
			var i:int;
			while (i < managedSounds.length) {
				managedSounds[i].stop();
				i++;
			};
		}
		public function update():void{
			var t:Number;
			var now:Number = getTimer();
			if (lastTime < 0){
				lastTime = now;
			};
			if (fadeStartTime >= 0){
				t = ((getTimer() - fadeStartTime) / (fadeEndTime - fadeStartTime));
				if (t < 0){
					t = 0;
				};
				if (t > 1){
					t = 1;
				};
				volume = (fadeStartVolume + ((fadeEndVolume - fadeStartVolume) * t));
				volume = (volume * volume);
				if (t == 1){
					fadeStartTime = -1;
				};
			};
			var i:int;
			while (i < managedSounds.length) {
				managedSounds[i].update();
				i++;
			};
		}

	}
}//package src.sound 
Section 27
//IFloat (src.timing.IFloat)
package src.timing {

	public class IFloat {

		public var ivalue:Number;
		private var lastValue:Number;

		private static var alpha:Number;

		public function IFloat(initial:Number){
			super();
			ivalue = initial;
			lastValue = initial;
			alpha = 0;
		}
		public function setTo(initial:Number){
			ivalue = initial;
			lastValue = initial;
		}
		public function set(newValue:Number){
			lastValue = ivalue;
			ivalue = newValue;
		}
		public function get(lalpha:Number){
			return ((lastValue + ((ivalue - lastValue) * lalpha)));
		}
		public function get value():Number{
			return ((lastValue + ((ivalue - lastValue) * alpha)));
		}
		public function set value(v:Number):void{
			ivalue = v;
			lastValue = v;
		}

		public static function setAlpha(na:Number):void{
			alpha = na;
		}

	}
}//package src.timing 
Section 28
//Timeable (src.timing.Timeable)
package src.timing {

	public interface Timeable {

		function tick(:Number):void;
		function render(_arg1:Number, _arg2:Number):void;

	}
}//package src.timing 
Section 29
//Timer (src.timing.Timer)
package src.timing {
	import flash.utils.*;

	public class Timer {

		private var time:Number;// = 0
		private var startTime:Number;// = -1
		private var lastTime:Number;// = 0
		private var unprocessedTime:Number;// = 0
		private var tick:Number;// = 0
		private var millisPerGameTick:Number;// = 0
		private var maxTickTime:Number;// = -1
		private var timeable:Timeable;

		public function Timer(timeable:Timeable, gameTicksPerSecond:Number){
			super();
			millisPerGameTick = (1000 / gameTicksPerSecond);
			this.timeable = timeable;
			this.maxTickTime = 500;
		}
		public function getMillisPerTick():Number{
			return (millisPerGameTick);
		}
		public function setMaxTickTime(millis:Number):void{
			maxTickTime = millis;
		}
		public function advanceTime2():void{
			var k:*;
			var t:* = getTimer();
			if (startTime < 0){
				startTime = t;
				unprocessedTime = millisPerGameTick;
			};
			time = (t - startTime);
			var passedTime:* = (time - lastTime);
			lastTime = time;
			unprocessedTime = (unprocessedTime + passedTime);
			if (unprocessedTime >= millisPerGameTick){
				k = (maxTickTime + t);
				do  {
					timeable.tick(tick);
					tick++;
					unprocessedTime = (unprocessedTime - millisPerGameTick);
				} while ((((unprocessedTime >= millisPerGameTick)) && ((getTimer() < k))));
			};
			var alpha:Number = ((unprocessedTime % millisPerGameTick) / millisPerGameTick);
			IFloat.setAlpha(alpha);
			timeable.render(tick, alpha);
		}
		public function advanceTime(){
			time = getTimer();
			var passedTime:* = (time - lastTime);
			lastTime = time;
			unprocessedTime = (unprocessedTime + passedTime);
			var ticked:Number = 0;
			while (unprocessedTime > millisPerGameTick) {
				unprocessedTime = (unprocessedTime - millisPerGameTick);
				timeable.tick(tick);
				tick++;
				ticked++;
				if (ticked >= 10){
					unprocessedTime = 0;
				};
			};
			var alpha:Number = (unprocessedTime / millisPerGameTick);
			timeable.render(tick, alpha);
		}

	}
}//package src.timing 
Section 30
//AnimationHandler (src.AnimationHandler)
package src {
	import flash.display.*;
	import flash.events.*;
	import src.timing.*;
	import src.comm.*;
	import src.math.*;
	import flash.utils.*;
	import flash.external.*;

	public class AnimationHandler {

		private var animationArr:Array;

		public function AnimationHandler(){
			super();
			animationArr = new Array();
		}
		public function tick():void{
			var i:* = 0;
			while (i < animationArr.length) {
				if (animationArr[i].mc != null){
					if (animationArr[i].delay == 0){
						animationArr[i].animationTo = Math.min((animationArr[i].animationTo + 1), animationArr[i].mc.totalFrames);
					} else {
						animationArr[i].delay--;
						if (animationArr[i].delay == 0){
							animationArr[i].mc.visible = true;
						};
					};
				};
				i++;
			};
			animationArr = animationArr.filter(isDone);
		}
		public function render():void{
			var i:* = 0;
			while (i < animationArr.length) {
				if (animationArr[i].mc != null){
					if (animationArr[i].mc.currentFrame != animationArr[i].animationTo){
						animationArr[i].mc.gotoAndStop(animationArr[i].animationTo);
					};
				};
				i++;
			};
		}
		public function addAnimation(mc:MovieClip, delay:Number, loop:Boolean, startFrame:Number):void{
			var obj:* = new Object();
			obj.mc = mc;
			obj.animationTo = startFrame;
			obj.delay = delay;
			obj.loop = loop;
			if (delay == 0){
				obj.mc.visible = true;
			};
			animationArr.push(obj);
		}
		public function isDone(element, index:int, arr:Array):Boolean{
			if (element.mc.parent == null){
				return (false);
			};
			if (element.loop){
				if (element.mc.currentFrame == element.mc.totalFrames){
					element.animationTo = 1;
				};
				return (true);
			};
			if ((((element.mc.currentFrame == element.mc.totalFrames)) || ((((element.animationTo == element.mc.totalFrames)) && ((element.mc.currentFrame == 1)))))){
				return (false);
			};
			return (true);
		}

	}
}//package src 
Section 31
//Ball (src.Ball)
package src {
	import flash.display.*;
	import src.timing.*;
	import src.math.*;

	public class Ball extends MovieClip {

		public var mcTail:MovieClip;
		public var mcBall:MovieClip;
		private var currentTick:Number;// = 0
		private var speed:Number;// = 10
		private var direction:Number;
		private var vy:Number;// = 0
		private var vx:Number;// = 0
		private var xFloat:IFloat;
		private var yFloat:IFloat;
		private var xPos:Number;
		private var yPos:Number;
		private var bonusBall:Boolean;
		private var radius:Number;
		private var tailAnimAt:Number;// = 1
		private var state:Number;
		private var gotoX:Number;
		private var gotoY:Number;
		private var game:Game;
		private var i:Number;
		private var newDirection:Boolean;// = true

		private static var BALL_RADIUS = 6;
		private static var BALL_DIAMETER = 12;
		private static var GAME_WIDTH = 500;
		private static var GAME_HEIGHT = 400;
		private static var STATE_INTRO = 0;
		private static var STATE_RUNNING = 1;
		private static var STATE_OUTRO = 2;

		public function Ball(bonusBall:Boolean, game:Game, i:Number){
			super();
			addFrameScript(0, frame1);
			this.game = game;
			this.bonusBall = bonusBall;
			this.i = i;
			direction = getRandom(359);
			speed = Number((getRandom(3) + 3));
			var a:* = getRandom(4);
			switch (a){
				case 0:
					xPos = (x = (15 + getRandom((GAME_WIDTH - 30))));
					yPos = (y = (-30 - getRandom(80)));
					break;
				case 1:
					xPos = (x = (15 + getRandom((GAME_WIDTH - 30))));
					yPos = (y = ((GAME_HEIGHT + 30) + getRandom(80)));
					break;
				case 2:
					xPos = (x = (-30 - getRandom(30)));
					yPos = (y = (15 + getRandom((GAME_HEIGHT - 30))));
					break;
				case 3:
					xPos = (x = ((GAME_WIDTH + 30) + getRandom(80)));
					yPos = (y = (15 + getRandom((GAME_HEIGHT - 30))));
					break;
			};
			gotoX = (15 + getRandom((GAME_WIDTH - 30)));
			gotoY = (15 + getRandom((GAME_HEIGHT - 30)));
			radius = BALL_RADIUS;
			if (!bonusBall){
				gotoAndStop((Math.floor((Math.random() * 4)) + 1));
			} else {
				radius = 18;
				gotoAndStop(6);
			};
			var a1:* = (gotoY - yPos);
			var b1:* = (gotoX - xPos);
			var radians1:* = XPMath.atan2(a1, b1);
			var degrees1:* = (radians1 / (Math.PI / 180));
			direction = (degrees1 + 90);
			xFloat = new IFloat(xPos);
			yFloat = new IFloat(yPos);
			tailAnimAt = (tailAnimAt + Math.floor((Math.random() * 115)));
			if (((!(bonusBall)) && (!((mcBall == null))))){
				mcBall.cacheAsBitmap = true;
			};
			state = STATE_INTRO;
		}
		public function tick(tick:Number):void{
			currentTick = tick;
			switch (state){
				case STATE_INTRO:
					if (newDirection){
						vy = XPMath.cos(degreesToRadians(direction));
						vx = XPMath.sin(degreesToRadians(direction));
						newDirection = false;
					};
					if ((((xPos < gotoX)) && (((xPos + (vx * speed)) > gotoX)))){
						xPos = gotoX;
						setRunning();
					};
					if ((((xPos > gotoX)) && (((xPos + (vx * speed)) < gotoX)))){
						xPos = gotoX;
						setRunning();
					} else {
						if (xPos == gotoX){
							xPos = gotoX;
							setRunning();
						} else {
							xPos = (xPos + (vx * speed));
						};
					};
					if ((((yPos < gotoY)) && (((yPos - (vy * speed)) > gotoY)))){
						yPos = gotoY;
						setRunning();
					};
					if ((((yPos > gotoY)) && (((yPos - (vy * speed)) < gotoY)))){
						yPos = gotoY;
						setRunning();
					} else {
						if (yPos == gotoY){
							yPos = gotoY;
							setRunning();
						} else {
							yPos = (yPos - (vy * speed));
						};
					};
					break;
				case STATE_RUNNING:
					if (newDirection){
						vy = XPMath.cos(degreesToRadians(direction));
						vx = XPMath.sin(degreesToRadians(direction));
						newDirection = false;
					};
					xPos = (xPos + (vx * speed));
					yPos = (yPos - (vy * speed));
					if (xPos <= (0 + BALL_RADIUS)){
						direction = ((360 - direction) % 360);
						newDirection = true;
					};
					if (xPos >= (GAME_WIDTH - BALL_RADIUS)){
						direction = ((360 - direction) % 360);
						newDirection = true;
					};
					if (yPos < (0 + BALL_RADIUS)){
						direction = ((180 - direction) % 360);
						newDirection = true;
					};
					if (yPos > ((0 + GAME_HEIGHT) - BALL_RADIUS)){
						direction = ((180 - direction) % 360);
						newDirection = true;
					};
					break;
				case STATE_OUTRO:
					vy = XPMath.cos(degreesToRadians(direction));
					vx = XPMath.sin(degreesToRadians(direction));
					xPos = (xPos + (vx * speed));
					yPos = (yPos - (vy * speed));
					direction = (direction + ((Math.random() * 30) - 15));
					speed++;
					break;
			};
			xFloat.set(xPos);
			yFloat.set(yPos);
			tailAnimAt = ((tailAnimAt + 1) % 117);
		}
		public function render(tick:Number, alpha:Number):void{
			if (rotation != direction){
				if (!bonusBall){
					mcTail.rotation = direction;
				};
			};
			if (x != xPos){
				x = int(xFloat.get(alpha));
			};
			if (y != yPos){
				y = int(yFloat.get(alpha));
			};
			if (!bonusBall){
				mcTail.gotoAndStop(Number((tailAnimAt + 1)));
			};
		}
		public function startRound():void{
		}
		public function degreesToRadians(degrees:Number):Number{
			return (((degrees * Math.PI) / 180));
		}
		public function getRadius():Number{
			return (radius);
		}
		public function getXpos():Number{
			return (xPos);
		}
		public function getYpos():Number{
			return (yPos);
		}
		public function setRadius():void{
			radius = (radius + 2);
			width = (radius * 2);
			height = (radius * 2);
		}
		public function setOutro():void{
			state = STATE_OUTRO;
		}
		public function setRunning():void{
			if (state == STATE_INTRO){
				state = STATE_RUNNING;
				game.ballReadyToStart();
			};
		}
		public function getRandom(num:Number):Number{
			return (game.getRandom(num));
		}
		function frame1(){
			stop();
		}

	}
}//package src 
Section 32
//Beems (src.Beems)
package src {
	import flash.display.*;
	import flash.events.*;
	import src.sound.*;
	import src.timing.*;
	import src.comm.*;
	import src.math.*;
	import flash.utils.*;
	import flash.external.*;

	public class Beems extends MovieClip {

		private var wobblyBubbly:WobblyBubbly;
		private var beemArr:Array;

		public function Beems(wobblyBubbly:WobblyBubbly){
			super();
			this.wobblyBubbly = wobblyBubbly;
			setupBeems();
		}
		public function tick(tick:Number):void{
			var i:* = 0;
			while (i < beemArr.length) {
				beemArr[i].rotPos = (beemArr[i].rotPos - beemArr[i].rotSpeed);
				if (beemArr[i].rotPos < -28){
					beemArr[i].alpha = (beemArr[i].maxAlpha - 0.1);
					beemArr[i].alphaMod = -1;
				};
				if (beemArr[i].rotPos < -30){
					beemArr[i].rotPos = 30;
					beemArr[i].float.setTo(beemArr[i].rotPos);
				};
				beemArr[i].float.set(beemArr[i].rotPos);
				if (beemArr[i].alpha < beemArr[i].maxAlpha){
					if (beemArr[i].alpha <= 0){
						if (Math.random() < 0.1){
							beemArr[i].alphaMod = 1;
							beemArr[i].alpha = 0;
						};
					};
					beemArr[i].alpha = Math.min(beemArr[i].maxAlpha, (beemArr[i].alpha + (0.05 * beemArr[i].alphaMod)));
				} else {
					if (Math.random() < 0.5){
						beemArr[i].alphaMod = -1;
						beemArr[i].alpha = beemArr[i].maxAlpha;
					};
				};
				i++;
			};
		}
		public function render(tick:Number, alpha:Number):void{
			var i:* = 0;
			while (i < beemArr.length) {
				beemArr[i].rotation = beemArr[i].float.get(alpha);
				i++;
			};
		}
		public function setupBeems():void{
			var b:*;
			beemArr = new Array();
			var noOfBeems:* = 3;
			var i:* = 0;
			while (i < noOfBeems) {
				b = new Beem();
				addChild(b);
				b.x = 250;
				b.rotPos = (b.rotation = ((Math.random() * 60) - 30));
				b.rotSpeed = Math.max(0.1, (Math.random() / 2));
				b.alphaMod = -1;
				b.maxAlpha = (b.alpha = Math.max(0.6, (Math.random() - 0.1)));
				b.scaleX = Math.max(0.2, Math.random());
				b.float = new IFloat(0);
				beemArr.push(b);
				i++;
			};
		}

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

	public dynamic class BonusBall extends MovieClip {

	}
}//package src 
Section 34
//CollisionObject (src.CollisionObject)
package src {
	import flash.display.*;
	import flash.events.*;
	import src.sound.*;
	import src.timing.*;
	import src.comm.*;
	import src.math.*;
	import flash.utils.*;
	import flash.text.*;
	import flash.external.*;

	public class CollisionObject extends MovieClip {

		public var txtScore:TextField;
		private var currentTick:Number;// = 0
		private var dFloat:IFloat;
		private var radius:Number;// = 0
		private var lifeSpan:Number;// = 75
		private var killCollisionObject:Boolean;// = false
		private var game:Game;
		private var rFloat:IFloat;
		private var xPos;
		private var yPos;
		private var chainValue:Number;

		private static var MAX_RADIUS = 35;

		public function CollisionObject(game:Game, theX:Number, theY:Number, chainValue:Number, score:Number){
			var a:*;
			var l:*;
			var n:*;
			var i:*;
			super();
			if (score == 0){
				txtScore.text = "";
			} else {
				a = String(score);
				l = [];
				n = 0;
				i = (a.length - 1);
				while (i >= 0) {
					l.push(a.charAt(i));
					if (((!((i == 0))) && ((_temp1 == 3)))){
						l.push(".");
						n = 0;
					};
					i--;
				};
				l = l.reverse().join("");
				txtScore.text = String(l);
			};
			this.game = game;
			xPos = (x = theX);
			yPos = (y = theY);
			width = (height = (radius = 0));
			rFloat = new IFloat(radius);
			this.chainValue = chainValue;
		}
		public function tick(tick:Number):void{
			currentTick = tick;
			if (lifeSpan > 10){
				radius = Math.min((radius + 2), MAX_RADIUS);
			} else {
				radius = Math.max((radius - 2.5), 0);
			};
			rFloat.set((radius * 2));
			lifeSpan--;
			if (lifeSpan == -1){
				killCollisionObject = true;
			};
		}
		public function render(tick:Number, alpha:Number):void{
			if (width != radius){
				width = (height = rFloat.get(alpha));
			};
		}
		public function getKillCollisionObject():Boolean{
			return (killCollisionObject);
		}
		public function getRadius():Number{
			return (radius);
		}
		public function getXpos():Number{
			return (xPos);
		}
		public function getYpos():Number{
			return (yPos);
		}
		public function getChainValue():Number{
			return (chainValue);
		}

	}
}//package src 
Section 35
//Game (src.Game)
package src {
	import flash.display.*;
	import flash.events.*;
	import src.sound.*;
	import src.timing.*;
	import src.comm.*;
	import src.math.*;
	import flash.utils.*;
	import flash.external.*;

	public class Game extends MovieClip {

		private var currentTick:Number;// = 0
		private var noOfBalls:Number;// = 60
		private var ballsArr:Array;
		private var collisionObjectArr:Array;
		private var wobblyBubbly:WobblyBubbly;
		private var score:Number;// = 0
		public var sfxManager:SoundManager;
		private var clicked:Boolean;// = false
		private var bonusBall:Ball;
		private var bonusScore:Number;// = 0
		private var state:Number;
		private var ballsNotStarted:Number;
		private var gameStarted:Boolean;// = false
		private var waterBitMap:BitmapData;
		private var _target:Bitmap;
		private var _rippler:Rippler;
		private var countDownTimer:Number;
		private var communicator:Communicator;
		private var startAnim:uint;// = 1
		private var userType_:Number;
		private var level:Number;

		private static var GAME_WIDTH = 500;
		private static var GAME_HEIGHT = 400;
		private static var BASE_SCORE = 100;
		private static var STATE_RUNNING = 0;
		private static var STATE_OUTRO = 1;

		public function Game(wobblyBubbly:WobblyBubbly, sfxManager:SoundManager, level:Number, communicator:Communicator, userType){
			super();
			this.level = level;
			this.userType_ = userType;
			this.wobblyBubbly = wobblyBubbly;
			this.sfxManager = sfxManager;
			this.communicator = communicator;
			wobblyBubbly.addEventListener(MouseEvent.MOUSE_DOWN, gameClicked);
			collisionObjectArr = new Array();
			ballsNotStarted = ((25 + (level * 5)) + 1);
			noOfBalls = (25 + (level * 5));
			wobblyBubbly.mcNumber.txtLevel.text = String(level);
			countDownTimer = (25 * 15);
			waterBitMap = new BitmapData(500, 400, true, 4294901760);
			waterBitMap.draw(wobblyBubbly.mcBG);
			_target = new Bitmap(waterBitMap);
			addChild(_target);
			_rippler = new Rippler(_target, 60, 6);
			createBalls();
			state = STATE_RUNNING;
		}
		public function tick(tick:Number):void{
			var i:*;
			var a:Number;
			var done:Boolean;
			currentTick = tick;
			switch (state){
				case STATE_RUNNING:
					i = 0;
					while (i < ballsArr.length) {
						ballsArr[i].tick(tick);
						i++;
					};
					i = 0;
					while (i < collisionObjectArr.length) {
						collisionObjectArr[i].tick(tick);
						if (collisionObjectArr[i].getKillCollisionObject()){
							removeChild(collisionObjectArr[i]);
							collisionObjectArr.splice(i, 1);
							i--;
						};
						i++;
					};
					checkCollision();
					if ((((collisionObjectArr.length == 0)) && (clicked))){
						outro();
					};
					if (gameStarted){
						countDownTimer--;
					};
					a = Math.max(Math.round((countDownTimer / 25)), 0);
					if (((!(clicked)) && (gameStarted))){
						startAnim++;
					};
					if (((!(clicked)) && ((countDownTimer <= 0)))){
						sfxManager.get("levelOver").play(0.5);
						outro();
					};
					break;
				case STATE_OUTRO:
					i = 0;
					while (i < ballsArr.length) {
						ballsArr[i].tick(tick);
						i++;
					};
					done = true;
					i = 0;
					while (i < ballsArr.length) {
						if ((((((((ballsArr[i].getXpos() > -30)) && ((ballsArr[i].getXpos() < (GAME_WIDTH + 30))))) && ((ballsArr[i].getYpos() > -30)))) && ((ballsArr[i].getYpos() < (GAME_HEIGHT + 30))))){
							done = false;
						};
						i++;
					};
					if (done){
						endRound();
					};
					break;
			};
		}
		public function render(tick:Number, alpha:Number):void{
			var i:*;
			if (_target != null){
			};
			if (!clicked){
				wobblyBubbly.mcNumber.gotoAndStop(startAnim);
			};
			i = 0;
			while (i < ballsArr.length) {
				ballsArr[i].render(tick, alpha);
				i++;
			};
			i = 0;
			while (i < collisionObjectArr.length) {
				collisionObjectArr[i].render(tick, alpha);
				i++;
			};
		}
		public function startRound():void{
		}
		public function createBalls():void{
			var b:*;
			ballsArr = new Array();
			var i:* = 0;
			while (i < noOfBalls) {
				b = new Ball(false, this, i);
				addChild(b);
				ballsArr.push(b);
				b.mouseChildren = false;
				b.mouseEnabled = false;
				i++;
			};
			bonusBall = new Ball(true, this, 999);
			addChild(bonusBall);
			ballsArr.push(bonusBall);
		}
		public function checkCollision():void{
			var p:*;
			var a:*;
			var b:*;
			var c:*;
			var i:* = 0;
			while (i < ballsArr.length) {
				p = 0;
				while (p < collisionObjectArr.length) {
					a = (Math.abs((ballsArr[i].getXpos() - collisionObjectArr[p].getXpos())) * Math.abs((ballsArr[i].getXpos() - collisionObjectArr[p].getXpos())));
					b = (Math.abs((ballsArr[i].getYpos() - collisionObjectArr[p].getYpos())) * Math.abs((ballsArr[i].getYpos() - collisionObjectArr[p].getYpos())));
					c = Math.sqrt((a + b));
					if ((ballsArr[i].getRadius() + collisionObjectArr[p].getRadius()) >= c){
						createCollisionObject(ballsArr[i].getXpos(), ballsArr[i].getYpos(), (collisionObjectArr[p].getChainValue() + 1), ballsArr[i]);
						removeChild(ballsArr[i]);
						ballsArr.splice(i, 1);
						i--;
						break;
					};
					p++;
				};
				i++;
			};
		}
		public function gameClicked(e:Event):void{
			if ((((((((mouseX < 0)) || ((mouseX > 498)))) || ((mouseY < 0)))) || ((mouseY > 398)))){
				return;
			};
			if (((((!(clicked)) && (gameStarted))) && ((state == STATE_RUNNING)))){
				communicator.gameClicked((currentTick + 1), mouseX, mouseY);
				createCollisionObject(mouseX, mouseY, 1, null);
				clicked = true;
			};
		}
		public function createCollisionObject(theX:Number, theY:Number, chainValue:Number, theBall:Ball):void{
			var scr:*;
			var i:uint;
			var rndNum:* = Math.floor((Math.random() * 8));
			sfxManager.get(("sfx" + rndNum)).play(0.5);
			_rippler.drawRipple(theX, theY, 20, 1);
			if (theBall == bonusBall){
				scr = bonusScore;
				bonusBall = null;
			} else {
				scr = 10;
				i = 0;
				while (i < (chainValue - 1)) {
					scr = Math.round((scr * 2));
					i++;
				};
				if (scr == 10){
					scr = 0;
				};
			};
			wobblyBubbly.setScore(scr);
			var cO:* = new CollisionObject(this, theX, theY, chainValue, scr);
			addChild(cO);
			collisionObjectArr.push(cO);
			if (bonusBall != null){
				bonusScore = (bonusScore + Math.round((scr * 0.5)));
				bonusBall.setRadius();
			};
		}
		public function outro():void{
			trace("start outro");
			var i:* = 0;
			while (i < ballsArr.length) {
				ballsArr[i].setOutro();
				i++;
			};
			state = STATE_OUTRO;
		}
		public function endRound():void{
			trace("endRound");
			wobblyBubbly.endRound(score);
		}
		public function ballReadyToStart():void{
			trace(("ballReady " + currentTick));
			ballsNotStarted--;
			if ((((((ballsNotStarted == 0)) && ((level == 2)))) && ((userType_ == 0)))){
				wobblyBubbly.slideOutText();
				outro();
			} else {
				if (ballsNotStarted == 0){
					trace(level);
					trace(userType_);
					gameStarted = true;
					wobblyBubbly.slideOutText();
				};
			};
		}
		private function handleMouseMove(event:MouseEvent):void{
			_rippler.drawRipple(mouseX, mouseY, 20, 1);
		}
		public function getRandom(num:Number):Number{
			return (wobblyBubbly.getRandom(num));
		}

	}
}//package src 
Section 36
//Rippler (src.Rippler)
package src {
	import flash.display.*;
	import flash.events.*;
	import flash.geom.*;
	import flash.filters.*;

	public class Rippler {

		private var _source:DisplayObject;
		private var _buffer1:BitmapData;
		private var _buffer2:BitmapData;
		private var _defData:BitmapData;
		private var _fullRect:Rectangle;
		private var _drawRect:Rectangle;
		private var _origin:Point;
		private var _filter:DisplacementMapFilter;
		private var _expandFilter:ConvolutionFilter;
		private var _colourTransform:ColorTransform;
		private var _matrix:Matrix;
		private var _scaleInv:Number;
		private var a:Number;// = 0

		public function Rippler(source:DisplayObject, strength:Number, scale:Number=2){
			var correctedScaleX:Number;
			var correctedScaleY:Number;
			_origin = new Point();
			super();
			_source = source;
			_scaleInv = (1 / scale);
			_buffer1 = new BitmapData((source.width * _scaleInv), (source.height * _scaleInv), false, 0);
			_buffer2 = new BitmapData(_buffer1.width, _buffer1.height, false, 0);
			_defData = new BitmapData(source.width, source.height, false, 0x7F7F7F);
			correctedScaleX = (_defData.width / _buffer1.width);
			correctedScaleY = (_defData.height / _buffer1.height);
			_fullRect = new Rectangle(0, 0, _buffer1.width, _buffer1.height);
			_drawRect = new Rectangle();
			_filter = new DisplacementMapFilter(_defData, _origin, BitmapDataChannel.BLUE, BitmapDataChannel.BLUE, strength, strength, "clamp");
			_source.filters = [_filter];
			_source.addEventListener(Event.ENTER_FRAME, handleEnterFrame);
			_expandFilter = new ConvolutionFilter(3, 3, [0.5, 1, 0.5, 1, 0, 1, 0.5, 1, 0.5], 3);
			_colourTransform = new ColorTransform(1, 1, 1, 1, 128, 128, 128);
			_matrix = new Matrix(correctedScaleX, 0, 0, correctedScaleY);
		}
		public function drawRipple(x:int, y:int, size:int, alpha:Number):void{
			var half = (size >> 1);
			var intensity:int = (((alpha * 0xFF) & 0xFF) * alpha);
			_drawRect.x = ((-(half) + x) * _scaleInv);
			_drawRect.y = ((-(half) + y) * _scaleInv);
			_drawRect.width = (_drawRect.height = (size * _scaleInv));
			_buffer1.fillRect(_drawRect, intensity);
		}
		public function getRippleImage():BitmapData{
			return (_defData);
		}
		public function destroy():void{
			_source.removeEventListener(Event.ENTER_FRAME, handleEnterFrame);
			_buffer1.dispose();
			_buffer2.dispose();
			_defData.dispose();
		}
		private function handleEnterFrame(event:Event):void{
			var temp:BitmapData = _buffer2.clone();
			_buffer2.applyFilter(_buffer1, _fullRect, _origin, _expandFilter);
			_buffer2.draw(temp, null, null, BlendMode.SUBTRACT, null, false);
			_defData.draw(_buffer2, _matrix, _colourTransform, null, null, true);
			_filter.mapBitmap = _defData;
			_source.filters = [_filter];
			temp.dispose();
			switchBuffers();
		}
		private function switchBuffers():void{
			var temp:BitmapData;
			temp = _buffer1;
			_buffer1 = _buffer2;
			_buffer2 = temp;
		}

	}
}//package src 
Section 37
//WobblyBubbly (src.WobblyBubbly)
package src {
	import flash.display.*;
	import flash.events.*;
	import src.sound.*;
	import src.timing.*;
	import src.comm.*;
	import src.math.*;
	import fl.transitions.easing.*;
	import fl.transitions.*;
	import flash.utils.*;
	import flash.text.*;
	import flash.external.*;

	public class WobblyBubbly extends MovieClip implements Timeable {

		public var mcNumber:MovieClip;
		public var txtFPS:TextField;
		public var mcBG:BackGround;
		public var mcQuitButton:MovieClip;
		public var mcGameContainer:MovieClip;
		public var mcBeemsContainer:MovieClip;
		public var mcSoundButton:MovieClip;
		public var mcMusicButton:MovieClip;
		public var mcTextContainer:MovieClip;
		public var mcScoreBoard:MovieClip;
		private var m_mainTimer;
		private var random:MtRandom;
		private var communicator:Communicator;
		public var parsedGameData:Object;// = null
		private var gameState;
		private var game_:Game;
		public var musicManager:SoundManager;
		public var sfxManager:SoundManager;
		private var currentTick:Number;// = 0
		private var clientVersion;// = "1.0"
		private var userType_:Number;
		private var animationHandler:AnimationHandler;
		private var sfxOn:Boolean;// = true
		private var musicOn:Boolean;// = true
		private var noOfRandoms:Number;// = 0
		private var timeLeft:Number;
		private var level:Number;// = 0
		private var score:Number;// = 0
		private var tX;
		private var gX;
		private var gY;
		private var gA;
		private var rX;
		private var rY;
		private var rA;
		private var beems:Beems;
		private var goSign:GoSign;
		private var readySign:ReadySign;
		private var gameOverSign;
		private var introSign;
		private var noOfRend;// = 0
		private var startTime;
		private var betweenSign:BetweenSign;
		private var txtScoreArr:Array;
		private var topScoreSign:TopScoreSign;

		private static var STATE_SHOW_INTRO_SCREEN = 0;
		private static var STATE_BETWEEN_ROUNDS = 1;
		private static var STATE_SHOW_STICKERS_SCREEN = 2;
		private static var STATE_PLAY_GAME = 3;
		private static var STATE_END_GAME = 4;
		private static var TICKS_PER_SEC = 25;
		private static var DEBUG_MODE = false;
		private static var DEBUG_GAME_DATA = ((((((((((((((("<gamedata randomseed=\"11180176\" timelimit=\"660\" lang=\"de\">" + "<text id=\"game_starts_in\">The game starts in [0] seconds!</text>") + "<text id=\"game_ends_in\">Game ends in [0] seconds!</text>") + "<text id=\"round_cleared\">Round Cleared!</text>") + "<text id=\"score\">Score:</text>") + "<text id=\"go\">GO!</text>") + "<text id=\"game_over\">Game Over</text>") + "<text id=\"game_over_open\">Register to play fullversion</text>") + "<text id=\"intro_text\">Click like mad to play this game. And please, PLEASE remember to bring back the bacon!!</text>") + "<text id=\"get_ready\">GET READY!</text>") + "<text id=\"level\">LEVEL</text>") + "<text id=\"max_score\">Max score achieved!</text>") + "<sounds id=\"sfxOn\">0</sounds>") + "<sounds id=\"musicOn\">0</sounds>") + "<userType id=\"1\">1</userType>") + "</gamedata>");

		public function WobblyBubbly(){
			var oa:Object;
			var gameData:String;
			musicManager = new SoundManager();
			sfxManager = new SoundManager();
			txtScoreArr = new Array();
			super();
			m_mainTimer = new Timer(this, TICKS_PER_SEC);
			addEventListener("enterFrame", drive);
			communicator = new Communicator();
			if (DEBUG_MODE){
				oa = new Object();
				oa.message = DEBUG_GAME_DATA;
				oa.success = true;
			} else {
				oa = ExternalInterface.call("getGameData");
			};
			if ((((oa == null)) || (!(oa.success)))){
				trace(("oa kuka ur " + oa));
			} else {
				gameData = oa.message;
				parsedGameData = GameDataParser.parseGameData(gameData);
				random = new MtRandom(parsedGameData.randomSeed);
				userType_ = Number(parsedGameData.userType);
				if (userType_ == 0){
				};
				mcNumber.txtLevelLabel.text = (("- " + parsedGameData.textMappings["level"].toUpperCase()) + " -");
			};
			animationHandler = new AnimationHandler();
			if (Number(parsedGameData.sounds["sfxOn"]) == 1){
				mcSoundButton.gotoAndStop(2);
				sfxOn = false;
				sfxManager.setVolume(0);
			};
			if (Number(parsedGameData.sounds["musicOn"]) == 1){
				mcMusicButton.gotoAndStop(2);
				musicOn = false;
				musicManager.setVolume(0);
			};
			mcQuitButton.addEventListener(MouseEvent.MOUSE_DOWN, quitButtonPressed);
			mcSoundButton.addEventListener(MouseEvent.MOUSE_DOWN, soundButtonPressed);
			mcMusicButton.addEventListener(MouseEvent.MOUSE_DOWN, musicButtonPressed);
			beems = new Beems(this);
			mcBeemsContainer.addChild(beems);
			showIntroScreen();
		}
		private function drive(e:Event){
			m_mainTimer.advanceTime2();
		}
		public function tick(tick:Number):void{
			currentTick = tick;
			animationHandler.tick();
			beems.tick(tick);
			switch (gameState){
				case STATE_SHOW_INTRO_SCREEN:
					timeLeft--;
					if (timeLeft == 25){
						introSign.y = (introSign.y - 25);
						readySign = new ReadySign();
						mcTextContainer.addChild(readySign);
						readySign.txtGetReady.text = parsedGameData.textMappings["get_ready"];
						readySign.x = 375;
						readySign.y = 300;
						rX = new Tween(readySign, "scaleX", Strong.easeIn, 0, 1, 1, true);
						rY = new Tween(readySign, "scaleY", Strong.easeIn, 0, 1, 1, true);
						rA = new Tween(readySign, "alpha", Strong.easeIn, 0, 1, 0.7, true);
					} else {
						if (timeLeft < 30){
							introSign.y = (introSign.y - 25);
						} else {
							introSign.y = Math.max(125, (introSign.y - 5));
						};
					};
					if (timeLeft == 0){
						introSign.mcFiller.removeEventListener(MouseEvent.MOUSE_DOWN, endIntro);
						mcTextContainer.removeChild(introSign);
						startRound();
					};
					break;
				case STATE_PLAY_GAME:
					game_.tick(tick);
					break;
				case STATE_BETWEEN_ROUNDS:
					timeLeft--;
					if (timeLeft == 25){
						mcTextContainer.removeChild(readySign);
						mcTextContainer.removeChild(goSign);
						tX = new Tween(betweenSign, "x", Strong.easeIn, 375, 900, 1, true);
						readySign = new ReadySign();
						mcTextContainer.addChild(readySign);
						readySign.txtGetReady.text = parsedGameData.textMappings["get_ready"];
						readySign.x = 375;
						readySign.y = 300;
						rX = new Tween(readySign, "scaleX", Strong.easeIn, 0, 1, 1, true);
						rY = new Tween(readySign, "scaleY", Strong.easeIn, 0, 1, 1, true);
						rA = new Tween(readySign, "alpha", Strong.easeIn, 0, 1, 0.7, true);
					};
					if (timeLeft == 0){
						startRound();
					};
					break;
				case STATE_END_GAME:
					timeLeft = Math.max((timeLeft - 1), 0);
					if (timeLeft == 0){
						gameQuit();
					};
					break;
			};
		}
		public function render(tick:Number, alpha:Number):void{
			var theFPS:*;
			musicManager.update();
			sfxManager.update();
			animationHandler.render();
			beems.render(tick, alpha);
			if (noOfRend == 0){
				startTime = getTimer();
			};
			noOfRend++;
			var a:* = (getTimer() - startTime);
			if (a > 2000){
				theFPS = Math.round(((noOfRend * 1000) / a));
				if (game_ != null){
					txtFPS.text = String(theFPS);
				};
				noOfRend = 0;
			};
			switch (gameState){
				case STATE_PLAY_GAME:
					game_.render(tick, alpha);
					break;
				case STATE_END_GAME:
					gameOverSign.txtTimeLeft.text = parsedGameData.textMappings["game_ends_in"].split("[0]").join(("" + Math.round((timeLeft / TICKS_PER_SEC))));
					break;
			};
		}
		public function addAnimation(obj:MovieClip, delay:Number, loop:Boolean, startFrame:Number):void{
			animationHandler.addAnimation(obj, delay, loop, startFrame);
		}
		public function showIntroScreen():void{
			musicManager.get("loop").loop();
			introSign = new IntroSign();
			mcTextContainer.addChild(introSign);
			introSign.txtIntro.text = parsedGameData.textMappings["intro_text"];
			introSign.x = 375;
			introSign.y = 510;
			introSign.mcFiller.addEventListener(MouseEvent.MOUSE_DOWN, endIntro);
			timeLeft = 260;
			gameState = STATE_SHOW_INTRO_SCREEN;
		}
		public function endIntro(e:Event):void{
			if (timeLeft > 26){
				timeLeft = 26;
			};
		}
		public function endOutro(e:Event):void{
			if (timeLeft > 2){
				timeLeft = 1;
			};
		}
		public function startRound():void{
			level++;
			mcQuitButton.visible = true;
			if (level == 1){
				if (!DEBUG_MODE){
					communicator.gameStarted();
				};
			};
			if (game_ == null){
				communicator.startRound((currentTick + 1));
				trace((("game is created at tick " + currentTick) + 1));
				game_ = new Game(this, sfxManager, level, communicator, userType_);
				mcGameContainer.addChild(game_);
			};
			gameState = STATE_PLAY_GAME;
		}
		public function gameQuit():void{
			communicator.gameQuit();
		}
		public function slideOutText():void{
			rX = new Tween(readySign, "scaleX", Strong.easeOut, 1, 0, 1, true);
			rY = new Tween(readySign, "scaleY", Strong.easeOut, 1, 0, 1, true);
			rA = new Tween(readySign, "alpha", Strong.easeOut, 1, 0, 0.7, true);
			goSign = new GoSign();
			mcTextContainer.addChild(goSign);
			goSign.x = 375;
			goSign.y = 300;
			goSign.txtGo.text = parsedGameData.textMappings["go"];
			goSign.mouseEnabled = false;
			goSign.mouseChildren = false;
			gX = new Tween(goSign, "scaleX", Elastic.easeOut, 0, 1, 0.5, true);
			gY = new Tween(goSign, "scaleY", Elastic.easeOut, 0, 1, 0.5, true);
			gA = new Tween(goSign, "alpha", Strong.easeIn, 1, 0, 1.4, true);
		}
		public function endRound(scr:Number):void{
			mcGameContainer.removeChild(game_);
			game_ = null;
			if ((((level == 2)) && ((userType_ == 0)))){
				openGameEnd();
			} else {
				if ((((level < 3)) && ((score < 2000000000)))){
					betweenRounds(scr);
				} else {
					endGame();
				};
			};
		}
		public function betweenRounds(scr:Number):void{
			mcQuitButton.visible = false;
			betweenSign = new BetweenSign();
			mcTextContainer.addChild(betweenSign);
			betweenSign.x = -1000;
			betweenSign.y = 300;
			betweenSign.mouseEnabled = false;
			betweenSign.mouseChildren = false;
			betweenSign.txtTitle.text = parsedGameData.textMappings["round_cleared"];
			betweenSign.txtScoreTitle.text = parsedGameData.textMappings["score"];
			var a:* = String(score);
			var l:* = [];
			var n:* = 0;
			var i:* = (a.length - 1);
			while (i >= 0) {
				l.push(a.charAt(i));
				if (((!((i == 0))) && ((_temp1 == 3)))){
					l.push(".");
					n = 0;
				};
				i--;
			};
			l = l.reverse().join("");
			betweenSign.txtScore.text = String(l);
			tX = new Tween(betweenSign, "x", Strong.easeOut, -600, 375, 0.6, true);
			timeLeft = (3 * TICKS_PER_SEC);
			gameState = STATE_BETWEEN_ROUNDS;
		}
		public function endGame():void{
			if (topScoreSign != null){
				topScoreSign.visible = false;
			};
			if (betweenSign != null){
				betweenSign.visible = false;
			};
			if (goSign != null){
				goSign.visible = false;
			};
			if (introSign != null){
				introSign.visible = false;
			};
			if (readySign != null){
				readySign.visible = false;
			};
			var mInt:* = 1;
			if (musicOn){
				mInt = 0;
			};
			var sInt:* = 1;
			if (sfxOn){
				sInt = 0;
			};
			communicator.lastTick((currentTick + 1), noOfRandoms, mInt, sInt);
			communicator.gameEnd(score);
			musicManager.get("loop").fadeTo(0, 1500);
			musicManager.get("gameOver").play();
			gameOverSign = new GameOver();
			addChild(gameOverSign);
			gameOverSign.mcFiller.addEventListener(MouseEvent.MOUSE_DOWN, endOutro);
			gameOverSign.x = 375;
			gameOverSign.y = 300;
			var a:* = String(score);
			var l:* = [];
			var n:* = 0;
			var i:* = (a.length - 1);
			while (i >= 0) {
				l.push(a.charAt(i));
				if (((!((i == 0))) && ((_temp1 == 3)))){
					l.push(".");
					n = 0;
				};
				i--;
			};
			l = l.reverse().join("");
			gameOverSign.txtGameOver.text = parsedGameData.textMappings["game_over"];
			gameOverSign.txtScore.text = String(l);
			timeLeft = 250;
			gameState = STATE_END_GAME;
		}
		public function openGameEnd():void{
			if (topScoreSign != null){
				topScoreSign.visible = false;
			};
			if (betweenSign != null){
				betweenSign.visible = false;
			};
			if (goSign != null){
				goSign.visible = false;
			};
			if (introSign != null){
				introSign.visible = false;
			};
			if (readySign != null){
				readySign.visible = false;
			};
			var mInt:* = 1;
			if (musicOn){
				mInt = 0;
			};
			var sInt:* = 1;
			if (sfxOn){
				sInt = 0;
			};
			communicator.gameEnd(score);
			musicManager.get("loop").fadeTo(0, 1500);
			musicManager.get("gameOver").play();
			gameOverSign = new GameOver();
			addChild(gameOverSign);
			gameOverSign.mcFiller.addEventListener(MouseEvent.MOUSE_DOWN, endOutro);
			gameOverSign.x = 375;
			gameOverSign.y = 300;
			var a:* = String(score);
			var l:* = [];
			var n:* = 0;
			var i:* = (a.length - 1);
			while (i >= 0) {
				l.push(a.charAt(i));
				if (((!((i == 0))) && ((_temp1 == 3)))){
					l.push(".");
					n = 0;
				};
				i--;
			};
			l = l.reverse().join("");
			gameOverSign.txtGameOverOpen.text = parsedGameData.textMappings["game_over_open"];
			gameOverSign.txtScore.text = String(l);
			timeLeft = 250;
			gameState = STATE_END_GAME;
		}
		public function quitButtonPressed(e:Event):void{
			var mInt:*;
			var sInt:*;
			if (gameState == STATE_PLAY_GAME){
				mInt = 1;
				if (musicOn){
					mInt = 0;
				};
				sInt = 1;
				if (sfxOn){
					sInt = 0;
				};
				communicator.lastTick((currentTick + 1), noOfRandoms, mInt, sInt);
				level = 3;
				game_.outro();
			};
		}
		public function musicButtonPressed(e:Event):void{
			if (musicOn){
				musicManager.fadeTo(0, 500);
				musicOn = false;
				mcMusicButton.gotoAndStop(2);
			} else {
				musicManager.fadeTo(1, 500);
				musicOn = true;
				mcMusicButton.gotoAndStop(1);
			};
		}
		public function soundButtonPressed(e:Event):void{
			if (sfxOn){
				sfxManager.fadeTo(0, 500);
				sfxOn = false;
				mcSoundButton.gotoAndStop(2);
			} else {
				sfxManager.fadeTo(1, 500);
				sfxOn = true;
				mcSoundButton.gotoAndStop(1);
			};
		}
		public function getRandom(num:Number):Number{
			noOfRandoms++;
			return (random.nextInt(num));
		}
		public function setScore(scr:Number):void{
			var tX:*;
			var tY:*;
			var tA:*;
			var st:Array;
			var i:*;
			txtScoreArr = [mcScoreBoard.txt0, mcScoreBoard.txt1, mcScoreBoard.txt2, mcScoreBoard.txt3, mcScoreBoard.txt4, mcScoreBoard.txt5, mcScoreBoard.txt6, mcScoreBoard.txt7, mcScoreBoard.txt8];
			score = Math.min((score + scr), 2000000000);
			if (score == 2000000000){
				topScoreSign = new TopScoreSign();
				mcTextContainer.addChild(topScoreSign);
				topScoreSign.txtTopScore = parsedGameData.textMappings["max_score"];
				topScoreSign.x = 375;
				topScoreSign.y = 300;
				tX = new Tween(topScoreSign, "scaleX", Strong.easeIn, 0, 1, 1, true);
				tY = new Tween(topScoreSign, "scaleY", Strong.easeIn, 0, 1, 1, true);
				tA = new Tween(topScoreSign, "alpha", Strong.easeIn, 0, 1, 0.7, true);
			};
			if (score > 0){
				st = String(score).split("");
				st.reverse();
				i = (st.length - 1);
				while (i >= 0) {
					txtScoreArr[i].text = st[i];
					i--;
				};
			};
		}

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

	public dynamic class BackGround extends MovieClip {

		public function BackGround(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

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

	public dynamic class Beem extends MovieClip {

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

	public dynamic class BetweenSign extends MovieClip {

		public var txtScore:TextField;
		public var txtScoreTitle:TextField;
		public var txtTitle:TextField;

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

	public dynamic class bTest extends MovieClip {

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

	public dynamic class GameOver extends MovieClip {

		public var txtScore:TextField;
		public var txtGameOver:TextField;
		public var mcFiller:MovieClip;
		public var txtGameOverOpen:TextField;
		public var txtTimeLeft:TextField;

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

	public dynamic class GameOverOpen extends MovieClip {

		public var txtScore:TextField;
		public var mcFiller:MovieClip;
		public var txtTimeLeft:TextField;

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

	public dynamic class GoSign extends MovieClip {

		public var txtGo:TextField;

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

	public dynamic class IntroSign extends MovieClip {

		public var txtIntro:TextField;
		public var mcFiller:MovieClip;

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

	public dynamic class ReadySign extends MovieClip {

		public var txtGetReady:TextField;

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

	public dynamic class TopScoreSign extends MovieClip {

		public var txtTopScore:TextField;

	}
}//package