Section 1
//KeyPoll (bigroom.input.KeyPoll)
package bigroom.input {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;

	public class KeyPoll {

		private var states:ByteArray;
		private var dispObj:DisplayObject;

		public function KeyPoll(_arg1:DisplayObject){
			states = new ByteArray();
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			states.writeUnsignedInt(0);
			dispObj = _arg1;
			dispObj.addEventListener(KeyboardEvent.KEY_DOWN, keyDownListener, false, 0, true);
			dispObj.addEventListener(KeyboardEvent.KEY_UP, keyUpListener, false, 0, true);
			dispObj.addEventListener(Event.ACTIVATE, activateListener, false, 0, true);
			dispObj.addEventListener(Event.DEACTIVATE, deactivateListener, false, 0, true);
		}
		public function isUp(_arg1:uint):Boolean{
			return (((states[(_arg1 >>> 3)] & (1 << (_arg1 & 7))) == 0));
		}
		private function activateListener(_arg1:Event):void{
			var _local2:int;
			_local2 = 0;
			while (_local2 < 32) {
				states[_local2] = 0;
				_local2++;
			};
		}
		private function deactivateListener(_arg1:Event):void{
			var _local2:int;
			_local2 = 0;
			while (_local2 < 32) {
				states[_local2] = 0;
				_local2++;
			};
		}
		public function isDown(_arg1:uint):Boolean{
			return (!(((states[(_arg1 >>> 3)] & (1 << (_arg1 & 7))) == 0)));
		}
		private function keyDownListener(_arg1:KeyboardEvent):void{
			states[(_arg1.keyCode >>> 3)] = (states[(_arg1.keyCode >>> 3)] | (1 << (_arg1.keyCode & 7)));
		}
		private function keyUpListener(_arg1:KeyboardEvent):void{
			states[(_arg1.keyCode >>> 3)] = (states[(_arg1.keyCode >>> 3)] & ~((1 << (_arg1.keyCode & 7))));
		}

	}
}//package bigroom.input 
Section 2
//ImageItem (br.com.stimuli.loading.loadingtypes.ImageItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import flash.display.*;
	import br.com.stimuli.loading.*;
	import flash.net.*;
	import flash.utils.*;

	public class ImageItem extends LoadingItem {

		public var loader:Loader;

		public function ImageItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			specificAvailableProps = [BulkLoader.CONTEXT];
			super(_arg1, _arg2, _arg3);
		}
		override public function stop():void{
			try {
				if (loader){
					loader.close();
				};
			} catch(e:Error) {
			};
			super.stop();
		}
		override public function _parseOptions(_arg1:Object):Array{
			context = ((_arg1[BulkLoader.CONTEXT]) || (null));
			return (super._parseOptions(_arg1));
		}
		override public function isImage():Boolean{
			return ((type == BulkLoader.TYPE_IMAGE));
		}
		public function _onHttpStatusHandler(_arg1:HTTPStatusEvent):void{
			_httpStatus = _arg1.status;
			dispatchEvent(_arg1);
		}
		override public function onErrorHandler(_arg1:Event):void{
			super.onErrorHandler(_arg1);
		}
		override public function load():void{
			super.load();
			loader = new Loader();
			loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, onProgressHandler, false, 0, true);
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteHandler, false, 0, true);
			loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false, 100, true);
			loader.contentLoaderInfo.addEventListener(Event.OPEN, onStartedHandler, false, 0, true);
			loader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false, 0, true);
			loader.load(url, context);
		}
		override public function cleanListeners():void{
			var _local1:Object;
			if (loader){
				_local1 = loader.contentLoaderInfo;
				_local1.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler, false);
				_local1.removeEventListener(Event.COMPLETE, onCompleteHandler, false);
				_local1.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false);
				_local1.removeEventListener(BulkLoader.OPEN, onStartedHandler, false);
				_local1.removeEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false);
			};
		}
		override public function isSWF():Boolean{
			return ((type == BulkLoader.TYPE_MOVIECLIP));
		}
		override public function onCompleteHandler(_arg1:Event):void{
			_content = loader.content;
			super.onCompleteHandler(_arg1);
		}
		override public function destroy():void{
			stop();
			cleanListeners();
			_content = null;
			loader = null;
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 3
//LoadingItem (br.com.stimuli.loading.loadingtypes.LoadingItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import flash.display.*;
	import br.com.stimuli.loading.*;
	import flash.net.*;
	import flash.utils.*;

	public class LoadingItem extends EventDispatcher {

		public var _priority:int;// = 0
		public var status:String;
		public var _type:String;
		public var _isLoaded:Boolean;
		public var _isLoading:Boolean;
		public var _additionIndex:int;
		public var _bytesTotal:int;// = -1
		public var _httpStatus:int;// = -1
		public var _content;
		public var _speed:Number;
		public var _weightPercentLoaded:Number;
		public var propertyParsingErrors:Array;
		public var url:URLRequest;
		public var weight:int;// = 1
		public var _addedTime:int;
		public var preventCache:Boolean;
		public var _uid:String;
		public var _responseTime:Number;
		public var maxTries:int;// = 3
		public var _bytesLoaded:int;// = 0
		public var _percentLoaded:Number;
		public var context;// = null
		public var _totalTime:int;
		public var numTries:int;// = 0
		public var _id:String;
		public var _latency:Number;
		public var _startTime:int;
		public var _bytesRemaining:int;// = 10000000
		public var _timeToDownload:int;
		public var specificAvailableProps:Array;

		public static const STATUS_STOPPED:String = "stopped";
		public static const STATUS_STARTED:String = "started";
		public static const STATUS_ERROR:String = "error";
		public static const STATUS_FINISHED:String = "finished";

		public function LoadingItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			_priority = 0;
			maxTries = 3;
			numTries = 0;
			weight = 1;
			_bytesTotal = -1;
			_bytesLoaded = 0;
			_bytesRemaining = 10000000;
			_httpStatus = -1;
			context = null;
			super();
			this._type = _arg2;
			this.url = _arg1;
			if (!specificAvailableProps){
				specificAvailableProps = [];
			};
			this._uid = _arg3;
		}
		public function onCompleteHandler(_arg1:Event):void{
			_totalTime = getTimer();
			_timeToDownload = ((_totalTime - _responseTime) / 1000);
			if (_timeToDownload == 0){
				_timeToDownload = 0.2;
			};
			_speed = BulkLoader.truncateNumber(((bytesTotal / 0x0400) / _timeToDownload));
			if (_timeToDownload == 0){
				_speed = 3000;
			};
			status = STATUS_FINISHED;
			_isLoaded = true;
			dispatchEvent(_arg1);
			_arg1.stopPropagation();
		}
		public function stop():void{
			if (_isLoaded){
				return;
			};
			status = STATUS_STOPPED;
			_isLoading = false;
		}
		public function isSound():Boolean{
			return (false);
		}
		public function get weightPercentLoaded():Number{
			return (_weightPercentLoaded);
		}
		public function get id():String{
			return (_id);
		}
		public function onHttpStatusHandler(_arg1:HTTPStatusEvent):void{
			_httpStatus = _arg1.status;
			dispatchEvent(_arg1);
		}
		public function get type():String{
			return (_type);
		}
		public function get speed():Number{
			return (_speed);
		}
		public function onStartedHandler(_arg1:Event):void{
			_responseTime = getTimer();
			_latency = BulkLoader.truncateNumber(((_responseTime - _startTime) / 1000));
			status = STATUS_STARTED;
			dispatchEvent(_arg1);
		}
		public function get bytesLoaded():int{
			return (_bytesLoaded);
		}
		public function isImage():Boolean{
			return (false);
		}
		public function _parseOptions(_arg1:Object):Array{
			var _local2:Array;
			var _local3:String;
			preventCache = _arg1[BulkLoader.PREVENT_CACHING];
			_id = _arg1[BulkLoader.ID];
			_priority = ((int(_arg1[BulkLoader.PRIORITY])) || (0));
			maxTries = ((_arg1[BulkLoader.MAX_TRIES]) || (3));
			weight = ((int(_arg1[BulkLoader.WEIGHT])) || (1));
			_local2 = BulkLoader.GENERAL_AVAILABLE_PROPS.concat(specificAvailableProps);
			propertyParsingErrors = [];
			for (_local3 in _arg1) {
				if (_local2.indexOf(_local3) == -1){
					propertyParsingErrors.push(((((this + ": got a wrong property name: ") + _local3) + ", with value:") + _arg1[_local3]));
				};
			};
			return (propertyParsingErrors);
		}
		public function get startTime():int{
			return (_startTime);
		}
		public function get totalTime():int{
			return (_totalTime);
		}
		override public function toString():String{
			return (((((("LoadingItem url: " + url.url) + ", type:") + _type) + ", status: ") + status));
		}
		public function isVideo():Boolean{
			return (false);
		}
		public function isText():Boolean{
			return (false);
		}
		public function get content(){
			return (_content);
		}
		public function onProgressHandler(_arg1):void{
			_bytesLoaded = _arg1.bytesLoaded;
			_bytesTotal = _arg1.bytesTotal;
			_bytesRemaining = (_bytesTotal - bytesLoaded);
			_percentLoaded = (_bytesLoaded / _bytesTotal);
			_weightPercentLoaded = (_percentLoaded * weight);
			dispatchEvent(_arg1);
		}
		public function get bytesTotal():int{
			return (_bytesTotal);
		}
		public function get httpStatus():int{
			return (_httpStatus);
		}
		public function isXML():Boolean{
			return (false);
		}
		public function onErrorHandler(_arg1:Event):void{
			var _local2:BulkErrorEvent;
			numTries++;
			status = STATUS_ERROR;
			_arg1.stopPropagation();
			if (numTries >= maxTries){
				_local2 = new BulkErrorEvent(BulkErrorEvent.ERROR);
				_local2.errors = [this];
				dispatchEvent(_local2);
			} else {
				status = null;
				load();
			};
		}
		public function get priority():int{
			return (_priority);
		}
		public function get percentLoaded():Number{
			return (_percentLoaded);
		}
		public function get responseTime():Number{
			return (_responseTime);
		}
		public function isStreamable():Boolean{
			return (false);
		}
		public function get bytesRemaining():int{
			return (_bytesRemaining);
		}
		public function get isLoaded():Boolean{
			return (_isLoaded);
		}
		public function get timeToDownload():int{
			return (_timeToDownload);
		}
		public function isLoader():Boolean{
			return (false);
		}
		public function load():void{
			var _local1:String;
			if (preventCache){
				_local1 = ((("BulkLoaderNoCache=" + _uid) + "_") + int(((Math.random() * 100) * getTimer())));
				if (url.url.indexOf("?") == -1){
					url.url = (url.url + ("?" + _local1));
				} else {
					url.url = (url.url + ("&" + _local1));
				};
			};
			_isLoading = true;
			_startTime = getTimer();
		}
		public function getStats():String{
			return ((((((((((("Item url:" + url.url) + ", total time: ") + _timeToDownload) + "(s), latency:") + _latency) + "(s), speed: ") + _speed) + " kb/s, size: ") + BulkLoader.truncateNumber((_bytesTotal / 0x0400))) + " kb"));
		}
		public function get addedTime():int{
			return (_addedTime);
		}
		public function cleanListeners():void{
		}
		public function isSWF():Boolean{
			return (false);
		}
		public function destroy():void{
			_content = null;
		}
		public function get latency():Number{
			return (_latency);
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 4
//SoundItem (br.com.stimuli.loading.loadingtypes.SoundItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import br.com.stimuli.loading.*;
	import flash.media.*;
	import flash.net.*;

	public class SoundItem extends LoadingItem {

		public var loader:Sound;

		public function SoundItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			specificAvailableProps = [BulkLoader.CONTEXT];
			super(_arg1, _arg2, _arg3);
		}
		override public function stop():void{
			try {
				if (loader){
					loader.close();
				};
			} catch(e:Error) {
			};
			super.stop();
		}
		override public function isSound():Boolean{
			return (true);
		}
		override public function onStartedHandler(_arg1:Event):void{
			_content = loader;
			super.onStartedHandler(_arg1);
		}
		override public function _parseOptions(_arg1:Object):Array{
			context = ((_arg1[BulkLoader.CONTEXT]) || (null));
			return (super._parseOptions(_arg1));
		}
		override public function onErrorHandler(_arg1:Event):void{
			super.onErrorHandler(_arg1);
		}
		override public function isStreamable():Boolean{
			return (true);
		}
		override public function load():void{
			super.load();
			loader = new Sound();
			loader.addEventListener(ProgressEvent.PROGRESS, onProgressHandler, false, 0, true);
			loader.addEventListener(Event.COMPLETE, onCompleteHandler, false, 0, true);
			loader.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false, 0, true);
			loader.addEventListener(Event.OPEN, onStartedHandler, false, 0, true);
			loader.load(url, context);
		}
		override public function cleanListeners():void{
			if (loader){
				loader.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler, false);
				loader.removeEventListener(Event.COMPLETE, onCompleteHandler, false);
				loader.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false);
				loader.removeEventListener(BulkLoader.OPEN, onStartedHandler, false);
			};
		}
		override public function onCompleteHandler(_arg1:Event):void{
			_content = loader;
			super.onCompleteHandler(_arg1);
		}
		override public function destroy():void{
			cleanListeners();
			stop();
			_content = null;
			loader = null;
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 5
//URLItem (br.com.stimuli.loading.loadingtypes.URLItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import br.com.stimuli.loading.*;
	import flash.net.*;

	public class URLItem extends LoadingItem {

		public var loader:URLLoader;

		public function URLItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			super(_arg1, _arg2, _arg3);
		}
		override public function stop():void{
			try {
				if (loader){
					loader.close();
				};
			} catch(e:Error) {
			};
			super.stop();
		}
		override public function onStartedHandler(_arg1:Event):void{
			super.onStartedHandler(_arg1);
		}
		override public function _parseOptions(_arg1:Object):Array{
			return (super._parseOptions(_arg1));
		}
		override public function isText():Boolean{
			return (true);
		}
		override public function load():void{
			super.load();
			loader = new URLLoader();
			loader.addEventListener(ProgressEvent.PROGRESS, onProgressHandler, false, 0, true);
			loader.addEventListener(Event.COMPLETE, onCompleteHandler, false, 0, true);
			loader.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false, 0, true);
			loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false, 0, true);
			loader.addEventListener(Event.OPEN, onStartedHandler, false, 0, true);
			loader.load(url);
		}
		override public function cleanListeners():void{
			if (loader){
				loader.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler, false);
				loader.removeEventListener(Event.COMPLETE, onCompleteHandler, false);
				loader.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false);
				loader.removeEventListener(BulkLoader.OPEN, onStartedHandler, false);
				loader.removeEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false);
			};
		}
		override public function onCompleteHandler(_arg1:Event):void{
			_content = loader.data;
			super.onCompleteHandler(_arg1);
		}
		override public function destroy():void{
			stop();
			cleanListeners();
			_content = null;
			loader = null;
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 6
//VideoItem (br.com.stimuli.loading.loadingtypes.VideoItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import flash.display.*;
	import br.com.stimuli.loading.*;
	import flash.net.*;
	import flash.utils.*;

	public class VideoItem extends LoadingItem {

		private var _canBeginStreaming:Boolean;// = false
		var stream:NetStream;
		private var dummyEventTrigger:Sprite;
		private var nc:NetConnection;
		private var _checkPolicyFile:Boolean;
		private var _metaData:Object;
		var pausedAtStart:Boolean;// = false

		public function VideoItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			pausedAtStart = false;
			_canBeginStreaming = false;
			specificAvailableProps = [BulkLoader.CHECK_POLICY_FILE, BulkLoader.PAUSED_AT_START];
			super(_arg1, _arg2, _arg3);
		}
		override public function stop():void{
			try {
				if (stream){
					stream.close();
				};
			} catch(e:Error) {
			};
			super.stop();
		}
		function onVideoMetadata(_arg1):void{
			_metaData = _arg1;
		}
		private function fireCanBeginStreamingEvent():void{
			var _local1:Event;
			if (_canBeginStreaming){
				return;
			};
			_canBeginStreaming = true;
			_local1 = new Event(BulkLoader.CAN_BEGIN_PLAYING);
			dispatchEvent(_local1);
		}
		override public function onStartedHandler(_arg1:Event):void{
			_content = stream;
			if (((pausedAtStart) && (stream))){
				stream.pause();
			};
			super.onStartedHandler(_arg1);
		}
		override public function _parseOptions(_arg1:Object):Array{
			pausedAtStart = ((_arg1[BulkLoader.PAUSED_AT_START]) || (false));
			_checkPolicyFile = ((_arg1[BulkLoader.CHECK_POLICY_FILE]) || (false));
			return (super._parseOptions(_arg1));
		}
		override public function isVideo():Boolean{
			return (true);
		}
		public function get metaData():Object{
			return (_metaData);
		}
		public function createNetStreamEvent(_arg1:Event):void{
			var _local2:Event;
			var _local3:Event;
			var _local4:ProgressEvent;
			var _local5:int;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			if ((((_bytesTotal == _bytesLoaded)) && ((_bytesTotal > 8)))){
				if (dummyEventTrigger){
					dummyEventTrigger.removeEventListener(Event.ENTER_FRAME, createNetStreamEvent, false);
				};
				_local2 = new Event(Event.COMPLETE);
				onCompleteHandler(_local2);
			} else {
				if ((((_bytesTotal == 0)) && ((stream.bytesTotal > 4)))){
					_local3 = new Event(Event.OPEN);
					onStartedHandler(_local3);
					_bytesLoaded = stream.bytesLoaded;
					_bytesTotal = stream.bytesTotal;
				} else {
					if (stream){
						_local4 = new ProgressEvent(ProgressEvent.PROGRESS, false, false, stream.bytesLoaded, stream.bytesTotal);
						if (((((isVideo()) && (metaData))) && (!(_canBeginStreaming)))){
							_local5 = (getTimer() - responseTime);
							_local6 = (bytesLoaded / (_local5 / 1000));
							_local7 = (_bytesRemaining / (_local6 * 0.8));
							_local8 = (metaData.duration - stream.bufferLength);
							if (_local8 > _local7){
								fireCanBeginStreamingEvent();
							};
						};
						super.onProgressHandler(_local4);
					};
				};
			};
		}
		override public function isStreamable():Boolean{
			return (true);
		}
		function onNetStatus(_arg1:NetStatusEvent):void{
			var _local2:Event;
			if (!stream){
				return;
			};
			stream.removeEventListener(NetStatusEvent.NET_STATUS, onNetStatus, false);
			if (_arg1.info.code == "NetStream.Play.Start"){
				_content = stream;
				_local2 = new Event(Event.OPEN);
				onStartedHandler(_local2);
			} else {
				if (_arg1.info.code == "NetStream.Play.StreamNotFound"){
					onErrorHandler(_arg1);
				};
			};
		}
		override public function load():void{
			var customClient:Object;
			super.load();
			nc = new NetConnection();
			nc.connect(null);
			stream = new NetStream(nc);
			stream.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false, 0, true);
			stream.addEventListener(NetStatusEvent.NET_STATUS, onNetStatus, false, 0, true);
			dummyEventTrigger = new Sprite();
			dummyEventTrigger.addEventListener(Event.ENTER_FRAME, createNetStreamEvent, false, 0, true);
			customClient = new Object();
			customClient.onCuePoint = function (... _args):void{
			};
			customClient.onMetaData = onVideoMetadata;
			customClient.onPlayStatus = function (... _args):void{
			};
			stream.client = customClient;
			stream.play(url.url, _checkPolicyFile);
			stream.seek(0);
		}
		override public function cleanListeners():void{
			if (stream){
				stream.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false);
				stream.removeEventListener(NetStatusEvent.NET_STATUS, onNetStatus, false);
			};
			if (dummyEventTrigger){
				dummyEventTrigger.removeEventListener(Event.ENTER_FRAME, createNetStreamEvent, false);
				dummyEventTrigger = null;
			};
		}
		override public function onCompleteHandler(_arg1:Event):void{
			_content = stream;
			super.onCompleteHandler(_arg1);
		}
		override public function destroy():void{
			if (stream){
			};
			stop();
			cleanListeners();
			stream = null;
			super.destroy();
		}
		public function get checkPolicyFile():Object{
			return (_checkPolicyFile);
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 7
//XMLItem (br.com.stimuli.loading.loadingtypes.XMLItem)
package br.com.stimuli.loading.loadingtypes {
	import flash.events.*;
	import br.com.stimuli.loading.*;
	import flash.net.*;

	public class XMLItem extends LoadingItem {

		public var loader:URLLoader;

		public function XMLItem(_arg1:URLRequest, _arg2:String, _arg3:String){
			super(_arg1, _arg2, _arg3);
		}
		override public function stop():void{
			try {
				if (loader){
					loader.close();
				};
			} catch(e:Error) {
			};
			super.stop();
		}
		override public function onStartedHandler(_arg1:Event):void{
			super.onStartedHandler(_arg1);
		}
		override public function _parseOptions(_arg1:Object):Array{
			return (super._parseOptions(_arg1));
		}
		override public function isText():Boolean{
			return (true);
		}
		override public function onErrorHandler(_arg1:Event):void{
			super.onErrorHandler(_arg1);
		}
		override public function load():void{
			super.load();
			loader = new URLLoader();
			loader.addEventListener(ProgressEvent.PROGRESS, onProgressHandler, false, 0, true);
			loader.addEventListener(Event.COMPLETE, onCompleteHandler, false, 0, true);
			loader.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false, 0, true);
			loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false, 0, true);
			loader.addEventListener(Event.OPEN, onStartedHandler, false, 0, true);
			loader.load(url);
		}
		override public function cleanListeners():void{
			if (loader){
				loader.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler, false);
				loader.removeEventListener(Event.COMPLETE, onCompleteHandler, false);
				loader.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler, false);
				loader.removeEventListener(BulkLoader.OPEN, onStartedHandler, false);
				loader.removeEventListener(HTTPStatusEvent.HTTP_STATUS, super.onHttpStatusHandler, false);
			};
		}
		override public function onCompleteHandler(_arg1:Event):void{
			_content = new XML(loader.data);
			super.onCompleteHandler(_arg1);
		}
		override public function destroy():void{
			stop();
			cleanListeners();
			_content = null;
			loader = null;
		}

	}
}//package br.com.stimuli.loading.loadingtypes 
Section 8
//BulkErrorEvent (br.com.stimuli.loading.BulkErrorEvent)
package br.com.stimuli.loading {
	import flash.events.*;

	public class BulkErrorEvent extends Event {

		public var name:String;
		public var errors:Array;

		public static const ERROR:String = "error";

		public function BulkErrorEvent(_arg1:String, _arg2:Boolean=true, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
			this.name = _arg1;
		}
		override public function toString():String{
			return (super.toString());
		}
		override public function clone():Event{
			var _local1:BulkErrorEvent;
			_local1 = new BulkErrorEvent(name, bubbles, cancelable);
			_local1.errors = (errors) ? errors.slice() : [];
			return (_local1);
		}

	}
}//package br.com.stimuli.loading 
Section 9
//BulkLoader (br.com.stimuli.loading.BulkLoader)
package br.com.stimuli.loading {
	import flash.events.*;
	import flash.display.*;
	import br.com.stimuli.loading.loadingtypes.*;
	import flash.media.*;
	import flash.net.*;
	import flash.utils.*;

	public class BulkLoader extends EventDispatcher {

		public var _itemsTotal:int;// = 0
		public var speedAvg:Number;
		public var _numConnections:int;// = 7
		public var _totalWeight:int;// = 0
		public var _bytesTotalCurrent:int;// = 0
		public var _itemsLoaded:int;// = 0
		public var totalTime:Number;
		public var _additionIndex:int;// = 0
		public var _bytesTotal:int;// = 0
		public var _speed:Number;
		public var _loadedRatio:Number;// = 0
		public var _isPaused:Boolean;// = true
		public var _isFinished:Boolean;
		public var _lastSpeedCheck:int;
		public var _name:String;
		public var _allowsAutoIDFromFileName:Boolean;// = false
		public var _contents:Dictionary;
		public var _logFunction:Function;
		public var _bytesLoaded:int;// = 0
		public var _connections:Array;
		public var logLevel:int;// = 20
		public var _percentLoaded:Number;// = 0
		public var _weightPercent:Number;
		public var _lastBytesCheck:int;
		public var _isRunning:Boolean;
		public var _id:int;
		public var _items:Array;
		public var _stringSubstitutions:Object;
		public var avgLatency:Number;
		public var _startTime:int;
		public var _speedTotal:Number;
		public var _endTIme:int;

		public static const LOG_INFO:int = 2;
		public static const HTTP_STATUS:String = "httpStatus";
		public static const CONTEXT:String = "context";
		public static const CAN_BEGIN_PLAYING:String = "canBeginPlaying";
		public static const TYPE_VIDEO:String = "video";
		public static const TYPE_TEXT:String = "text";
		public static const TYPE_MOVIECLIP:String = "movieclip";
		public static const PREVENT_CACHING:String = "preventCache";
		public static const PAUSED_AT_START:String = "pausedAtStart";
		public static const TYPE_SOUND:String = "sound";
		public static const PROGRESS:String = "progress";
		public static const DEFAULT_LOG_LEVEL:int = 20;
		public static const ID:String = "id";
		public static const CHECK_POLICY_FILE:String = "checkPolicyFile";
		public static const COMPLETE:String = "complete";
		public static const PRIORITY:String = "priority";
		public static const MAX_TRIES:String = "maxTries";
		public static const VERSION:String = "rev 196 (0.9.9.4)";
		public static const AVAILABLE_TYPES:Array = [TYPE_VIDEO, TYPE_XML, TYPE_TEXT, TYPE_SOUND, TYPE_MOVIECLIP, TYPE_IMAGE];
		public static const LOG_VERBOSE:int = 0;
		public static const OPEN:String = "open";
		public static const LOG_WARNINGS:int = 3;
		public static const DEFAULT_NUM_CONNECTIONS:int = 7;
		public static const GENERAL_AVAILABLE_PROPS:Array = [WEIGHT, MAX_TRIES, HEADERS, ID, PRIORITY, PREVENT_CACHING, "type"];
		public static const LOG_SILENT:int = 10;
		public static const ERROR:String = "error";
		public static const HEADERS:String = "headers";
		public static const LOG_ERRORS:int = 4;
		public static const TYPE_IMAGE:String = "image";
		public static const TYPE_XML:String = "xml";
		public static const WEIGHT:String = "weight";

		public static var IMAGE_EXTENSIONS:Array = ["jpg", "jpeg", "gif", "png"];
		public static var _customTypesExtensions:Object;
		public static var MOVIECLIP_EXTENSIONS:Array = ["swf"];
		public static var XML_EXTENSIONS:Array = ["xml"];
		public static var _typeClasses:Object = {image:ImageItem, movieclip:ImageItem, xml:XMLItem, video:VideoItem, sound:SoundItem, text:URLItem};
		public static var TEXT_EXTENSIONS:Array = ["txt", "js", "php", "asp", "py"];
		public static var _instancesCreated:int = 0;
		public static var AVAILABLE_EXTENSIONS:Array = ["swf", "jpg", "jpeg", "gif", "png", "flv", "mp3", "xml", "txt", "js"];
		public static var SOUND_EXTENSIONS:Array = ["mp3", "f4a", "f4b"];
		public static var VIDEO_EXTENSIONS:Array = ["flv", "f4v", "f4p"];
		public static var _allLoaders:Object = {};

		public function BulkLoader(_arg1:String, _arg2:int=7, _arg3:int=20){
			_items = [];
			_contents = new Dictionary();
			_additionIndex = 0;
			_numConnections = DEFAULT_NUM_CONNECTIONS;
			_loadedRatio = 0;
			_itemsTotal = 0;
			_itemsLoaded = 0;
			_totalWeight = 0;
			_bytesTotal = 0;
			_bytesTotalCurrent = 0;
			_bytesLoaded = 0;
			_percentLoaded = 0;
			logLevel = DEFAULT_LOG_LEVEL;
			_allowsAutoIDFromFileName = false;
			_isPaused = true;
			_logFunction = trace;
			super();
			if (Boolean(_allLoaders[_arg1])){
				__debug_print_loaders();
				throw (new Error((("BulkLoader with name'" + _arg1) + "' has already been created.")));
			};
			if (!_arg1){
				throw (new Error("Cannot create a BulkLoader instance without a name"));
			};
			_allLoaders[_arg1] = this;
			if (_arg2 > 0){
				this._numConnections = _arg2;
			};
			this.logLevel = _arg3;
			_name = _arg1;
			_instancesCreated++;
			_id = _instancesCreated;
			_additionIndex = 0;
		}
		public function get allowsAutoIDFromFileName():Boolean{
			return (_allowsAutoIDFromFileName);
		}
		public function _onItemComplete(_arg1:Event):void{
			var _local2:LoadingItem;
			var _local3:Boolean;
			var _local4:Boolean;
			_local2 = (_arg1.target as LoadingItem);
			_removeFromConnections(_local2);
			log("Loaded ", _local2, LOG_INFO);
			log("Items to load", getNotLoadedItems(), LOG_VERBOSE);
			_local2.cleanListeners();
			_contents[_local2.url.url] = _local2.content;
			_local3 = _loadNext();
			_local4 = _isAllDoneP();
			_itemsLoaded++;
			if (_local4){
				_onAllLoaded();
			};
		}
		public function get loadedRatio():Number{
			return (_loadedRatio);
		}
		public function loadNow(_arg1):Boolean{
			var _local2:LoadingItem;
			var _local3:LoadingItem;
			if ((_arg1 is LoadingItem)){
				_local2 = _arg1;
			} else {
				_local2 = get(_arg1);
			};
			if (!_local2){
				return (false);
			};
			if (!_connections){
				_connections = [];
			};
			if ((((_local2.status == LoadingItem.STATUS_FINISHED)) || ((_local2.status == LoadingItem.STATUS_STARTED)))){
				return (true);
			};
			if (_connections.length >= numConnections){
				_local3 = _getLeastUrgentOpenedItem();
				_removeFromConnections(_local3);
				_local3.status = null;
			};
			_local2._priority = highestPriority;
			_loadNext(_local2);
			return (true);
		}
		public function set allowsAutoIDFromFileName(_arg1:Boolean):void{
			_allowsAutoIDFromFileName = _arg1;
		}
		public function _getContentAsType(_arg1, _arg2:Class, _arg3:Boolean=false){
			var item:LoadingItem;
			var res:*;
			var key = _arg1;
			var type = _arg2;
			var clearMemory = _arg3;
			if (!_name){
				throw (new Error("[BulkLoader] Cannot use an instance that has been cleared from memory (.clear())"));
			};
			item = get(key);
			if (!item){
				return (null);
			};
			try {
				if (((item._isLoaded) || (((item.isStreamable()) && ((item.status == LoadingItem.STATUS_STARTED)))))){
					res = (item.content as type);
					if (res == null){
						throw (new Error("bad cast"));
					};
					if (clearMemory){
						remove(key);
					};
					return (res);
				};
			} catch(e:Error) {
				log((("Failed to get content with url: '" + key) + "'as type:"), type, LOG_ERRORS);
			};
			return (null);
		}
		public function set stringSubstitutions(_arg1:Object):void{
			_stringSubstitutions = _arg1;
		}
		public function get contents():Object{
			return (_contents);
		}
		public function get id():int{
			return (_id);
		}
		public function getBitmap(_arg1:String, _arg2:Boolean=false):Bitmap{
			return (Bitmap(_getContentAsType(_arg1, Bitmap, _arg2)));
		}
		public function _removeFromConnections(_arg1):Boolean{
			var _local2:int;
			if (!_connections){
				return (false);
			};
			_local2 = _connections.indexOf(_arg1);
			if (_local2 > -1){
				_connections.splice(_local2, 1);
				return (true);
			};
			return (false);
		}
		public function resume(_arg1):Boolean{
			var _local2:LoadingItem;
			_local2 = ((_arg1 is LoadingItem)) ? _arg1 : get(_arg1);
			_isPaused = false;
			if (((_local2) && ((_local2.status == LoadingItem.STATUS_STOPPED)))){
				_local2.status = null;
				_loadNext();
				return (true);
			};
			return (false);
		}
		public function _onAllLoaded():void{
			var _local1:BulkProgressEvent;
			var _local2:BulkProgressEvent;
			if (_isFinished){
				return;
			};
			_local1 = new BulkProgressEvent(COMPLETE);
			_local1.setInfo(bytesLoaded, bytesTotal, bytesTotalCurrent, _itemsLoaded, itemsTotal, weightPercent);
			_local2 = new BulkProgressEvent(PROGRESS);
			_local2.setInfo(bytesLoaded, bytesTotal, bytesTotalCurrent, _itemsLoaded, itemsTotal, weightPercent);
			_isRunning = false;
			_endTIme = getTimer();
			totalTime = BulkLoader.truncateNumber(((_endTIme - _startTime) / 1000));
			_updateStats();
			_connections = [];
			getStats();
			_isFinished = true;
			log("Finished all", LOG_INFO);
			dispatchEvent(_local2);
			dispatchEvent(_local1);
		}
		public function removePausedItems():Boolean{
			var stoppedLoads:Array;
			stoppedLoads = _items.filter(function (_arg1:LoadingItem, ... _args):Boolean{
				return ((_arg1.status == LoadingItem.STATUS_STOPPED));
			});
			stoppedLoads.forEach(function (_arg1:LoadingItem, ... _args):void{
				remove(_arg1);
			});
			_loadNext();
			return ((stoppedLoads.length > 0));
		}
		public function resumeAll():Boolean{
			var affected:Boolean;
			log("Resuming all items", LOG_VERBOSE);
			affected = false;
			_items.forEach(function (_arg1:LoadingItem, ... _args):void{
				if (_arg1.status == LoadingItem.STATUS_STOPPED){
					resume(_arg1);
					affected = true;
				};
			});
			_loadNext();
			return (affected);
		}
		public function get isRunning():Boolean{
			return (_isRunning);
		}
		public function getNetStreamMetaData(_arg1:String, _arg2:Boolean=false):Object{
			var _local3:NetStream;
			_local3 = getNetStream(_arg1, _arg2);
			return ((Boolean(_local3)) ? (get(_arg1) as Object).metaData : null);
		}
		public function get logFunction():Function{
			return (_logFunction);
		}
		public function getProgressForItems(_arg1:Array):BulkProgressEvent{
			var _local2:Number;
			var _local3:int;
			var _local4:int;
			var _local5:Number;
			var _local6:int;
			var _local7:int;
			var _local8:int;
			var _local9:int;
			var _local10:int;
			var _local11:LoadingItem;
			var _local12:Array;
			var _local13:*;
			var _local14:BulkProgressEvent;
			_bytesLoaded = (_bytesTotal = (_bytesTotalCurrent = 0));
			_local2 = 0;
			_local3 = 0;
			_local4 = 0;
			_local5 = 0;
			_local6 = 0;
			_local7 = 0;
			_local8 = 0;
			_local9 = 0;
			_local10 = 0;
			_local12 = [];
			for each (_local13 in _arg1) {
				_local11 = ((_local13 is LoadingItem)) ? _local13 : get(_local13);
				if (!_local11){
				} else {
					_local6++;
					_local3 = (_local3 + _local11.weight);
					if ((((((_local11.status == LoadingItem.STATUS_STARTED)) || ((_local11.status == LoadingItem.STATUS_FINISHED)))) || ((_local11.status == LoadingItem.STATUS_STOPPED)))){
						_local8 = (_local8 + _local11._bytesLoaded);
						_local10 = (_local10 + _local11._bytesTotal);
						_local5 = (_local5 + ((_local11._bytesLoaded / _local11._bytesTotal) * _local11.weight));
						if (_local11.status == LoadingItem.STATUS_FINISHED){
							_local7++;
						};
						_local4++;
					};
				};
			};
			if (_local4 != _local6){
				_local9 = Number.POSITIVE_INFINITY;
			} else {
				_local9 = _local10;
			};
			_local2 = (_local5 / _local3);
			if (_local3 == 0){
				_local2 = 0;
			};
			_local14 = new BulkProgressEvent(PROGRESS);
			_local14.setInfo(_local8, _local9, _local9, _local7, _local6, _local2);
			return (_local14);
		}
		public function getContent(_arg1:String, _arg2:Boolean=false){
			return (_getContentAsType(_arg1, Object, _arg2));
		}
		public function getSerializedData(_arg1, _arg2:Boolean=false, _arg3:Function=null){
			var raw:*;
			var parsed:*;
			var key = _arg1;
			var clearMemory = _arg2;
			var encodingFunction = _arg3;
			try {
				raw = _getContentAsType(key, Object, clearMemory);
				parsed = encodingFunction.apply(null, [raw]);
				return (parsed);
			} catch(e:Error) {
				log("Failed to parse key:", key, ("with encodingFunction:" + encodingFunction), LOG_ERRORS);
			};
			return (null);
		}
		public function log(... _args):void{
			var _local2:int;
			_local2 = (isNaN(_args[(_args.length - 1)])) ? 3 : int(_args.pop());
			if (_local2 >= logLevel){
				_logFunction(("[BulkLoader] " + _args.join(" ")));
			};
		}
		public function get bytesLoaded():int{
			return (_bytesLoaded);
		}
		public function _loadNext(_arg1:LoadingItem=null):Boolean{
			var next:Boolean;
			var checkItem:LoadingItem;
			var toLoad = _arg1;
			if (_isFinished){
				return (false);
			};
			if (!_connections){
				_connections = [];
			};
			_connections.forEach(function (_arg1:LoadingItem, ... _args):void{
				if ((((_arg1.status == LoadingItem.STATUS_ERROR)) && ((_arg1.numTries < _arg1.maxTries)))){
					_removeFromConnections(_arg1);
				};
			});
			next = false;
			if (!toLoad){
				for each (checkItem in _items) {
					if (((!(checkItem._isLoading)) && (!((checkItem.status == LoadingItem.STATUS_STOPPED))))){
						toLoad = checkItem;
						break;
					};
				};
			};
			if (toLoad){
				next = true;
				_isRunning = true;
				if (_connections.length < numConnections){
					_connections.push(toLoad);
					toLoad.load();
					log("Will load item:", toLoad, LOG_INFO);
				};
				if (_connections.length < numConnections){
					_loadNext();
				};
			};
			return (next);
		}
		public function getSound(_arg1, _arg2:Boolean=false):Sound{
			return (Sound(_getContentAsType(_arg1, Sound, _arg2)));
		}
		public function get speed():Number{
			var _local1:int;
			var _local2:int;
			var _local3:int;
			_local1 = (getTimer() - _lastSpeedCheck);
			_local2 = ((bytesLoaded - _lastBytesCheck) / 0x0400);
			_local3 = (_local2 / (_local1 / 1000));
			_lastSpeedCheck = _local1;
			_lastBytesCheck = bytesLoaded;
			return (_local3);
		}
		public function get(_arg1):LoadingItem{
			var _local2:LoadingItem;
			if (!_arg1){
				return (null);
			};
			for each (_local2 in _items) {
				if ((((((((_local2._id == _arg1)) || ((_local2.url.url == _arg1)))) || ((_local2.url == _arg1)))) || ((((_arg1 is URLRequest)) && ((_local2.url.url == _arg1.url)))))){
					return (_local2);
				};
			};
			return (null);
		}
		public function removeFailedItems():int{
			var numCleared:int;
			var badItems:Array;
			numCleared = 0;
			badItems = _items.filter(function (_arg1:LoadingItem, ... _args):Boolean{
				return ((_arg1.status == LoadingItem.STATUS_ERROR));
			});
			numCleared = badItems.length;
			badItems.forEach(function (_arg1:LoadingItem, ... _args):void{
				remove(_arg1);
			});
			_loadNext();
			return (numCleared);
		}
		public function get highestPriority():int{
			var _local1:int;
			var _local2:LoadingItem;
			_local1 = int.MIN_VALUE;
			for each (_local2 in _items) {
				if (_local2.priority > _local1){
					_local1 = _local2.priority;
				};
			};
			return (_local1);
		}
		public function start(_arg1:int=-1):void{
			if (_arg1 > 0){
				_numConnections = _arg1;
			};
			if (_connections){
				_loadNext();
				return;
			};
			_startTime = getTimer();
			_connections = [];
			_loadNext();
			_isRunning = true;
			_lastBytesCheck = 0;
			_lastSpeedCheck = getTimer();
			_isPaused = false;
		}
		public function _getLeastUrgentOpenedItem():LoadingItem{
			var _local1:LoadingItem;
			_local1 = LoadingItem(_connections.sortOn(["priority", "bytesRemaining", "_additionIndex"], [Array.NUMERIC, Array.DESCENDING, Array.NUMERIC, Array.NUMERIC])[0]);
			return (_local1);
		}
		override public function toString():String{
			return (((((("[BulkLoader] name:" + name) + ", itemsTotal: ") + itemsTotal) + ", itemsLoaded: ") + _itemsLoaded));
		}
		public function getBitmapData(_arg1, _arg2:Boolean=false):BitmapData{
			var key = _arg1;
			var clearMemory = _arg2;
			try {
				return (getBitmap(key, clearMemory).bitmapData);
			} catch(e:Error) {
				log("Failed to get bitmapData with url:", key, LOG_ERRORS);
			};
			return (null);
		}
		public function set logFunction(_arg1:Function):void{
			_logFunction = _arg1;
		}
		public function clear():void{
			removeAll();
			delete _allLoaders[name];
			_name = null;
		}
		public function get itemsTotal():int{
			return (items.length);
		}
		public function sortItemsByPriority():void{
			_items.sortOn(["priority", "_additionIndex"], [(Array.NUMERIC | Array.DESCENDING), Array.NUMERIC]);
		}
		public function get stringSubstitutions():Object{
			return (_stringSubstitutions);
		}
		public function get name():String{
			return (_name);
		}
		public function remove(_arg1):Boolean{
			var item:LoadingItem;
			var allDone:Boolean;
			var key = _arg1;
			try {
				if ((key is LoadingItem)){
					item = key;
				} else {
					item = get(key);
				};
				if (!item){
					return (false);
				};
				_removeFromItems(item);
				_removeFromConnections(item);
				item.destroy();
				item = null;
				_onProgress();
				allDone = _isAllDoneP();
				if (allDone){
					_onAllLoaded();
				};
				return (true);
			} catch(e:Error) {
				log(("Error while removing item from key:" + key), e.getStackTrace(), LOG_ERRORS);
			};
			return (false);
		}
		public function removeAll():void{
			var _local1:LoadingItem;
			for each (_local1 in _items.slice()) {
				remove(_local1);
			};
			_items = [];
			_connections = [];
			_contents = new Dictionary();
		}
		public function _updateStats():void{
			var _local1:Number;
			var _local2:int;
			var _local3:Number;
			var _local4:LoadingItem;
			avgLatency = 0;
			speedAvg = 0;
			_local1 = 0;
			_local2 = 0;
			_speedTotal = 0;
			_local3 = 0;
			for each (_local4 in _items) {
				if (((_local4._isLoaded) && (!((_local4.status == LoadingItem.STATUS_ERROR))))){
					_local1 = (_local1 + _local4.latency);
					_local2 = (_local2 + _local4.bytesTotal);
					_local3++;
				};
			};
			_speedTotal = ((_local2 / 0x0400) / totalTime);
			avgLatency = (_local1 / _local3);
			speedAvg = (_speedTotal / _local3);
		}
		public function reload(_arg1):Boolean{
			var _local2:LoadingItem;
			if ((_arg1 is LoadingItem)){
				_local2 = _arg1;
			} else {
				_local2 = get(_arg1);
			};
			if (!_local2){
				return (false);
			};
			_removeFromItems(_local2);
			_removeFromConnections(_local2);
			_local2.stop();
			_local2.cleanListeners();
			_local2.status = null;
			_isFinished = false;
			_local2._addedTime = getTimer();
			_local2._additionIndex = _additionIndex++;
			_local2.addEventListener(Event.COMPLETE, _onItemComplete, false, int.MIN_VALUE, true);
			_local2.addEventListener(ERROR, _onItemError, false, 0, true);
			_local2.addEventListener(Event.OPEN, _onItemStarted, false, 0, true);
			_local2.addEventListener(ProgressEvent.PROGRESS, _onProgress, false, 0, true);
			_items.push(_local2);
			_itemsTotal = (_itemsTotal + 1);
			_totalWeight = (_totalWeight + _local2.weight);
			sortItemsByPriority();
			_isFinished = false;
			loadNow(_local2);
			return (true);
		}
		public function _onItemStarted(_arg1:Event):void{
			var _local2:LoadingItem;
			_local2 = (_arg1.target as LoadingItem);
			log("Started loading", _local2, LOG_INFO);
			dispatchEvent(_arg1);
		}
		public function add(_arg1, _arg2:Object=null):LoadingItem{
			var _local3:LoadingItem;
			var _local4:String;
			var _local5:Array;
			var _local6:String;
			if (!_name){
				throw (new Error("[BulkLoader] Cannot use an instance that has been cleared from memory (.clear())"));
			};
			if (((!(_arg1)) || (!(String(_arg1))))){
				throw (new Error("[BulkLoader] Cannot add an item with a null url"));
			};
			_arg2 = ((_arg2) || ({}));
			if ((_arg1 is String)){
				_arg1 = new URLRequest(BulkLoader.substituteURLString(_arg1, _stringSubstitutions));
				if (_arg2[HEADERS]){
					_arg1.requestHeaders = _arg2[HEADERS];
				};
			} else {
				if ((!(_arg1) is URLRequest)){
					throw (new Error(("[BulkLoader] cannot add object with bad type for url:'" + _arg1.url)));
				};
			};
			_local3 = get(_arg2[ID]);
			if (_local3){
				log((("Add received an already added id: " + _arg2[ID]) + ", not adding a new item"));
				return (_local3);
			};
			if (_arg2["type"]){
				_local4 = _arg2["type"].toLowerCase();
				if (AVAILABLE_TYPES.indexOf(_local4) == -1){
					log("add received an unknown type:", _local4, "and will cast it to text", LOG_WARNINGS);
				};
			};
			if (!_local4){
				_local4 = guessType(_arg1.url);
			};
			_additionIndex++;
			_local3 = new _typeClasses[_local4](_arg1, _local4, ((_instancesCreated + "_") + String(_additionIndex)));
			if (((!(_arg2["id"])) && (_allowsAutoIDFromFileName))){
				_arg2["id"] = getFileName(_arg1.url);
				log("Adding automatic id from file name for item:", _local3, (("( id= " + _arg2["id"]) + " )"));
			};
			_local5 = _local3._parseOptions(_arg2);
			for each (_local6 in _local5) {
				log(_local6, LOG_WARNINGS);
			};
			log("Added", _local3, LOG_VERBOSE);
			_local3._addedTime = getTimer();
			_local3._additionIndex = _additionIndex;
			_local3.addEventListener(Event.COMPLETE, _onItemComplete, false, int.MIN_VALUE, true);
			_local3.addEventListener(ERROR, _onItemError, false, 0, true);
			_local3.addEventListener(Event.OPEN, _onItemStarted, false, 0, true);
			_local3.addEventListener(ProgressEvent.PROGRESS, _onProgress, false, 0, true);
			_items.push(_local3);
			_itemsTotal = (_itemsTotal + 1);
			_totalWeight = (_totalWeight + _local3.weight);
			sortItemsByPriority();
			_isFinished = false;
			if (!_isPaused){
				_loadNext();
			};
			return (_local3);
		}
		public function getText(_arg1, _arg2:Boolean=false):String{
			return (String(_getContentAsType(_arg1, String, _arg2)));
		}
		public function get bytesTotal():int{
			return (_bytesTotal);
		}
		public function get percentLoaded():Number{
			return (_percentLoaded);
		}
		public function get weightPercent():Number{
			return (_weightPercent);
		}
		public function get bytesTotalCurrent():int{
			return (_bytesTotalCurrent);
		}
		public function getAVM1Movie(_arg1:String, _arg2:Boolean=false):AVM1Movie{
			return (AVM1Movie(_getContentAsType(_arg1, AVM1Movie, _arg2)));
		}
		public function get isFinished():Boolean{
			return (_isFinished);
		}
		public function changeItemPriority(_arg1:String, _arg2:int):Boolean{
			var _local3:LoadingItem;
			_local3 = get(_arg1);
			if (!_local3){
				return (false);
			};
			_local3._priority = _arg2;
			sortItemsByPriority();
			return (true);
		}
		public function get items():Array{
			return (_items.slice());
		}
		public function getNetStream(_arg1:String, _arg2:Boolean=false):NetStream{
			return (NetStream(_getContentAsType(_arg1, NetStream, _arg2)));
		}
		public function getHttpStatus(_arg1):int{
			var _local2:LoadingItem;
			_local2 = get(_arg1);
			if (_local2){
				return (_local2.httpStatus);
			};
			return (-1);
		}
		public function set itemsLoaded(_arg1:int):void{
			_itemsLoaded = _arg1;
		}
		public function _onProgress(_arg1:Event=null):void{
			var _local2:BulkProgressEvent;
			_local2 = getProgressForItems(_items);
			_bytesLoaded = _local2.bytesLoaded;
			_bytesTotal = _local2.bytesTotal;
			_weightPercent = _local2.weightPercent;
			_percentLoaded = _local2.percentLoaded;
			_bytesTotalCurrent = _local2.bytesTotalCurrent;
			_loadedRatio = _local2.ratioLoaded;
			dispatchEvent(_local2);
		}
		public function hasItem(_arg1, _arg2:Boolean=true):Boolean{
			var _local3:*;
			var _local4:BulkLoader;
			if (_arg2){
				_local3 = _allLoaders;
			} else {
				_local3 = [this];
			};
			for each (_local4 in _local3) {
				if (_hasItemInBulkLoader(_arg1, _local4)){
					return (true);
				};
			};
			return (false);
		}
		public function _removeFromItems(_arg1:LoadingItem):Boolean{
			var _local2:int;
			_local2 = _items.indexOf(_arg1);
			if (_local2 > -1){
				_items.splice(_local2, 1);
			} else {
				return (false);
			};
			if (_arg1._isLoaded){
				_itemsLoaded--;
			};
			_itemsTotal--;
			_totalWeight = (_totalWeight - _arg1.weight);
			log(("Removing " + _arg1), LOG_VERBOSE);
			return (true);
		}
		public function _isAllDoneP():Boolean{
			return (_items.every(function (_arg1:LoadingItem, ... _args):Boolean{
				return (_arg1._isLoaded);
			}));
		}
		public function _onItemError(_arg1:BulkErrorEvent):void{
			var item:LoadingItem;
			var bulkErrorEvent:BulkErrorEvent;
			var evt = _arg1;
			item = (evt.target as LoadingItem);
			log(((("After " + item.numTries) + " I am giving up on ") + item.url.url), LOG_ERRORS);
			log("Error loading", item, LOG_ERRORS);
			_removeFromConnections(item);
			evt.stopPropagation();
			bulkErrorEvent = new BulkErrorEvent(BulkErrorEvent.ERROR);
			bulkErrorEvent.errors = _items.filter(function (_arg1:LoadingItem, ... _args):Boolean{
				return ((_arg1.status == LoadingItem.STATUS_ERROR));
			});
			dispatchEvent(bulkErrorEvent);
		}
		public function pauseAll():void{
			var _local1:LoadingItem;
			for each (_local1 in _items) {
				pause(_local1);
			};
			_isRunning = false;
			_isPaused = true;
			log("Stopping all items", LOG_INFO);
		}
		public function getNotLoadedItems():Array{
			return (_items.filter(function (_arg1:LoadingItem, ... _args):Boolean{
				return (!((_arg1.status == LoadingItem.STATUS_FINISHED)));
			}));
		}
		public function getXML(_arg1, _arg2:Boolean=false):XML{
			return (XML(_getContentAsType(_arg1, XML, _arg2)));
		}
		public function get totalWeight():int{
			return (_totalWeight);
		}
		public function get itemsLoaded():int{
			return (_itemsLoaded);
		}
		public function getMovieClip(_arg1:String, _arg2:Boolean=false):MovieClip{
			return (MovieClip(_getContentAsType(_arg1, MovieClip, _arg2)));
		}
		public function get numConnections():int{
			return (_numConnections);
		}
		public function getStats():String{
			var stats:Array;
			var itemsInfo:Array;
			var statsString:String;
			stats = [];
			stats.push("\n************************************");
			stats.push((("All items loaded(" + itemsTotal) + ")"));
			stats.push(("Total time(s):   	" + totalTime));
			stats.push(("Average latency(s):  " + truncateNumber(avgLatency)));
			stats.push(("Average speed(kb/s): " + truncateNumber(speedAvg)));
			stats.push(("Median speed(kb/s):  " + truncateNumber(_speedTotal)));
			stats.push(("KiloBytes total: 	" + truncateNumber((bytesTotal / 0x0400))));
			itemsInfo = _items.map(function (_arg1:LoadingItem, ... _args):String{
				return (("\t" + _arg1.getStats()));
			});
			stats.push(itemsInfo.join("\n"));
			stats.push("************************************");
			statsString = stats.join("\n");
			log(statsString, LOG_VERBOSE);
			return (statsString);
		}
		public function pause(_arg1, _arg2:Boolean=false):Boolean{
			var _local3:LoadingItem;
			var _local4:Boolean;
			_local3 = ((_arg1 is LoadingItem)) ? _arg1 : get(_arg1);
			if (!_local3){
				return (false);
			};
			_local3.stop();
			log("STOPPED ITEM:", _local3, LOG_INFO);
			_local4 = _removeFromConnections(_local3);
			if (_arg2){
				_loadNext();
			};
			return (_local4);
		}

		public static function __debug_printStackTrace():void{
			try {
				throw (new Error("stack trace"));
			} catch(e:Error) {
			};
		}
		public static function pauseAllLoaders():void{
			var _local1:BulkLoader;
			for each (_local1 in _allLoaders) {
				_local1.pauseAll();
			};
		}
		public static function _hasItemInBulkLoader(_arg1, _arg2:BulkLoader):Boolean{
			var _local3:LoadingItem;
			_local3 = _arg2.get(_arg1);
			if (((_local3) && (_local3._isLoaded))){
				return (true);
			};
			return (false);
		}
		public static function getUniqueName():String{
			return (("BulkLoader-" + _instancesCreated));
		}
		public static function substituteURLString(_arg1:String, _arg2:Object):String{
			var _local3:RegExp;
			var _local4:Object;
			var _local5:String;
			var _local6:Array;
			var _local7:int;
			var _local8:Array;
			var _local9:Object;
			var _local10:Object;
			var _local11:String;
			var _local12:String;
			if (!_arg2){
				return (_arg1);
			};
			_local3 = /(?P<var_name>\{\s*[^\}]*\})/g;
			_local4 = _local3.exec(_arg1);
			_local5 = (_local4) ? _local4.var_name : null;
			_local6 = [];
			_local7 = 0;
			while (((Boolean(_local4)) && (Boolean(_local4.var_name)))) {
				if (_local4.var_name){
					_local5 = _local4.var_name;
					_local5 = _local5.replace("{", "");
					_local5 = _local5.replace("}", "");
					_local5 = _local5.replace(/\s*/g, "");
				};
				_local6.push({start:_local4.index, end:(_local4.index + _local4.var_name.length), changeTo:_arg2[_local5]});
				_local7++;
				if (_local7 > 400){
					break;
				};
				_local4 = _local3.exec(_arg1);
				_local5 = (_local4) ? _local4.var_name : null;
			};
			if (_local6.length == 0){
				return (_arg1);
			};
			_local8 = [];
			_local11 = _arg1.substr(0, _local6[0].start);
			for each (_local10 in _local6) {
				if (_local9){
					_local11 = _arg1.substring(_local9.end, _local10.start);
				};
				_local8.push(_local11);
				_local8.push(_local10.changeTo);
				_local9 = _local10;
			};
			_local8.push(_arg1.substring(_local10.end));
			return (_local8.join(""));
		}
		public static function createUniqueNamedLoader(_arg1:int=7, _arg2:int=20):BulkLoader{
			return (new BulkLoader(BulkLoader.getUniqueName(), _arg1, _arg2));
		}
		public static function whichLoaderHasItem(_arg1):BulkLoader{
			var _local2:BulkLoader;
			for each (_local2 in _allLoaders) {
				if (BulkLoader._hasItemInBulkLoader(_arg1, _local2)){
					return (_local2);
				};
			};
			return (null);
		}
		public static function removeAllLoaders():void{
			var _local1:BulkLoader;
			for each (_local1 in _allLoaders) {
				_local1.removeAll();
				_local1.clear();
				_local1 = null;
			};
			_allLoaders = {};
		}
		public static function __debug_print_num_loaders():void{
			var _local1:int;
			var _local2:String;
			_local1 = 0;
			for each (_local2 in BulkLoader._allLoaders) {
				_local1++;
			};
		}
		public static function getFileName(_arg1:String):String{
			var _local2:int;
			var _local3:String;
			var _local4:int;
			var _local5:String;
			if (_arg1.lastIndexOf("/") == (_arg1.length - 1)){
				return (getFileName(_arg1.substring(0, (_arg1.length - 1))));
			};
			_local2 = (_arg1.lastIndexOf("/") + 1);
			_local3 = _arg1.substring(_local2);
			_local4 = _local3.indexOf(".");
			if (_local4 == -1){
				if (_local3.indexOf("?") > -1){
					_local4 = _local3.indexOf("?");
				} else {
					_local4 = _local3.length;
				};
			};
			_local5 = _local3.substring(0, _local4);
			return (_local5);
		}
		public static function guessType(_arg1:String):String{
			var _local2:String;
			var _local3:String;
			var _local4:String;
			var _local5:String;
			var _local6:String;
			_local2 = ((_arg1.indexOf("?") > -1)) ? _arg1.substring(0, _arg1.indexOf("?")) : _arg1;
			_local3 = _local2.substring((_local2.lastIndexOf(".") + 1)).toLowerCase();
			if (!Boolean(_local3)){
				_local3 = BulkLoader.TYPE_TEXT;
			};
			if ((((_local3 == BulkLoader.TYPE_IMAGE)) || ((BulkLoader.IMAGE_EXTENSIONS.indexOf(_local3) > -1)))){
				_local4 = BulkLoader.TYPE_IMAGE;
			} else {
				if ((((_local3 == BulkLoader.TYPE_SOUND)) || ((BulkLoader.SOUND_EXTENSIONS.indexOf(_local3) > -1)))){
					_local4 = BulkLoader.TYPE_SOUND;
				} else {
					if ((((_local3 == BulkLoader.TYPE_VIDEO)) || ((BulkLoader.VIDEO_EXTENSIONS.indexOf(_local3) > -1)))){
						_local4 = BulkLoader.TYPE_VIDEO;
					} else {
						if ((((_local3 == BulkLoader.TYPE_XML)) || ((BulkLoader.XML_EXTENSIONS.indexOf(_local3) > -1)))){
							_local4 = BulkLoader.TYPE_XML;
						} else {
							if ((((_local3 == BulkLoader.TYPE_MOVIECLIP)) || ((BulkLoader.MOVIECLIP_EXTENSIONS.indexOf(_local3) > -1)))){
								_local4 = BulkLoader.TYPE_MOVIECLIP;
							} else {
								for (_local5 in _customTypesExtensions) {
									for each (_local6 in _customTypesExtensions[_local5]) {
										if (_local6 == _local3){
											_local4 = _local5;
											break;
										};
										if (_local4){
											break;
										};
									};
								};
								if (!_local4){
									_local4 = BulkLoader.TYPE_TEXT;
								};
							};
						};
					};
				};
			};
			return (_local4);
		}
		public static function getLoader(_arg1:String):BulkLoader{
			return ((BulkLoader._allLoaders[_arg1] as BulkLoader));
		}
		public static function registerNewType(_arg1:String, _arg2:String, _arg3:Class):Boolean{
			var _local4:Array;
			var _local5:Object;
			if (_arg1.charAt(0) == "."){
				_arg1 = _arg1.substring(1);
			};
			if (AVAILABLE_TYPES.indexOf(_arg2) == -1){
				if (((!(Boolean(_arg3))) || (!((_arg3 is LoadingItem))))){
					throw (new Error("[BulkLoader]: When adding a new type and extension, you must determine which class to use"));
				};
				_typeClasses[_arg2] = _arg3;
				if (!_customTypesExtensions[_arg2]){
					_customTypesExtensions[_arg2] = [];
					AVAILABLE_TYPES.push(_arg2);
				};
				_customTypesExtensions[_arg2].push(_arg1);
				return (true);
			};
			_local5 = {IMAGE_EXTENSIONS:TYPE_IMAGE, VIDEO_EXTENSIONS:TYPE_VIDEO, SOUND_EXTENSIONS:TYPE_SOUND, TEXT_EXTENSIONS:TYPE_TEXT};
			_local4 = _local5[_arg2];
			if (((_local4) && ((_local4.indexOf(_arg1) == -1)))){
				_local4.push(_arg1);
				return (true);
			};
			return (false);
		}
		public static function __debug_print_loaders():void{
			var theNames:Array;
			var instNames:String;
			theNames = [];
			for each (instNames in BulkLoader._allLoaders) {
				theNames.push(instNames);
			};
			theNames.sort();
			theNames.forEach(function (_arg1, ... _args):void{
			});
		}
		public static function truncateNumber(_arg1:Number, _arg2:int=2):Number{
			var _local3:int;
			_local3 = Math.pow(10, _arg2);
			return ((Math.round((_arg1 * _local3)) / _local3));
		}

	}
}//package br.com.stimuli.loading 
Section 10
//BulkProgressEvent (br.com.stimuli.loading.BulkProgressEvent)
package br.com.stimuli.loading {
	import flash.events.*;

	public class BulkProgressEvent extends ProgressEvent {

		public var name:String;
		public var _bytesLoaded:int;
		public var bytesTotalCurrent:int;
		public var itemsTotal:int;
		public var itemsLoaded:int;
		public var _percentLoaded:Number;
		public var _weightPercent:Number;
		public var _ratioLoaded:Number;

		public static const COMPLETE:String = "complete";
		public static const PROGRESS:String = "progress";

		public function BulkProgressEvent(_arg1:String, _arg2:Boolean=true, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
			this.name = _arg1;
		}
		public function get percentLoaded():Number{
			return (_percentLoaded);
		}
		public function set ratioLoaded(_arg1:Number):void{
			if (((isNaN(_arg1)) || (!(isFinite(_arg1))))){
				_arg1 = 0;
			};
			_ratioLoaded = _arg1;
		}
		public function loadingStatus():String{
			var _local1:Array;
			_local1 = [];
			_local1.push(("bytesLoaded: " + bytesLoaded));
			_local1.push(("bytesTotal: " + bytesTotal));
			_local1.push(("itemsLoaded: " + itemsLoaded));
			_local1.push(("itemsTotal: " + itemsTotal));
			_local1.push(("bytesTotalCurrent: " + bytesTotalCurrent));
			_local1.push(("percentLoaded: " + BulkLoader.truncateNumber(percentLoaded)));
			_local1.push(("weightPercent: " + BulkLoader.truncateNumber(weightPercent)));
			_local1.push(("ratioLoaded: " + BulkLoader.truncateNumber(ratioLoaded)));
			return ((("BulkProgressEvent " + _local1.join(", ")) + ";"));
		}
		public function set weightPercent(_arg1:Number):void{
			if (((isNaN(_arg1)) || (!(isFinite(_arg1))))){
				_arg1 = 0;
			};
			_weightPercent = _arg1;
		}
		public function set percentLoaded(_arg1:Number):void{
			if (((isNaN(_arg1)) || (!(isFinite(_arg1))))){
				_arg1 = 0;
			};
			_percentLoaded = _arg1;
		}
		override public function clone():Event{
			var _local1:BulkProgressEvent;
			_local1 = new BulkProgressEvent(name, bubbles, cancelable);
			_local1.setInfo(bytesLoaded, bytesTotal, bytesTotalCurrent, itemsLoaded, itemsTotal, weightPercent);
			return (_local1);
		}
		override public function toString():String{
			return (super.toString());
		}
		public function get weightPercent():Number{
			return (_weightPercent);
		}
		public function setInfo(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:Number):void{
			this._bytesLoaded = _arg1;
			this.bytesLoaded = _arg1;
			this.bytesTotal = _arg2;
			this.bytesTotalCurrent = _arg3;
			this.itemsLoaded = _arg4;
			this.itemsTotal = _arg5;
			this.weightPercent = _arg6;
			this.percentLoaded = ((_arg2 > 0)) ? (_arg1 / _arg2) : 0;
			ratioLoaded = ((_arg5 == 0)) ? 0 : (_arg4 / _arg5);
		}
		public function get ratioLoaded():Number{
			return (_ratioLoaded);
		}

	}
}//package br.com.stimuli.loading 
Section 11
//None (fl.transitions.easing.None)
package fl.transitions.easing {

	public class None {

		public static function easeOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			return ((((_arg3 * _arg1) / _arg4) + _arg2));
		}
		public static function easeIn(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			return ((((_arg3 * _arg1) / _arg4) + _arg2));
		}
		public static function easeInOut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			return ((((_arg3 * _arg1) / _arg4) + _arg2));
		}
		public static function easeNone(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			return ((((_arg3 * _arg1) / _arg4) + _arg2));
		}

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

	public class Tween extends EventDispatcher {

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

		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){
			isPlaying = false;
			obj = null;
			prop = "";
			func = function (_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
				return ((((_arg3 * _arg1) / _arg4) + _arg2));
			};
			begin = NaN;
			change = NaN;
			useSeconds = false;
			prevTime = NaN;
			prevPos = NaN;
			looping = false;
			_duration = NaN;
			_time = NaN;
			_fps = NaN;
			_position = NaN;
			_startTime = NaN;
			_intervalID = 0;
			_finish = NaN;
			_timer = null;
			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 continueTo(_arg1:Number, _arg2:Number):void{
			this.begin = this.position;
			this.finish = _arg1;
			if (!isNaN(_arg2)){
				this.duration = _arg2;
			};
			this.start();
		}
		public function stop():void{
			this.stopEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_STOP, this._time, this._position));
		}
		private function fixTime():void{
			if (this.useSeconds){
				this._startTime = (getTimer() - (this._time * 1000));
			};
		}
		public function set FPS(_arg1:Number):void{
			var _local2:Boolean;
			_local2 = this.isPlaying;
			this.stopEnterFrame();
			this._fps = _arg1;
			if (_local2){
				this.startEnterFrame();
			};
		}
		public function get finish():Number{
			return ((this.begin + this.change));
		}
		public function get duration():Number{
			return (this._duration);
		}
		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;
		}
		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();
				};
			};
		}
		protected function stopEnterFrame():void{
			if (isNaN(this._fps)){
				_mc.removeEventListener(Event.ENTER_FRAME, this.onEnterFrame);
			} else {
				this._timer.stop();
			};
			this.isPlaying = false;
		}
		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 set finish(_arg1:Number):void{
			this.change = (_arg1 - this.begin);
		}
		public function set duration(_arg1:Number):void{
			this._duration = ((_arg1)<=0) ? Infinity : _arg1;
		}
		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 resume():void{
			this.fixTime();
			this.startEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_RESUME, this._time, this._position));
		}
		public function fforward():void{
			this.time = this._duration;
			this.fixTime();
		}
		protected function onEnterFrame(_arg1:Event):void{
			this.nextFrame();
		}
		public function get position():Number{
			return (this.getPosition(this._time));
		}
		public function yoyo():void{
			this.continueTo(this.begin, this.time);
		}
		public function nextFrame():void{
			if (this.useSeconds){
				this.time = ((getTimer() - this._startTime) / 1000);
			} else {
				this.time = (this._time + 1);
			};
		}
		protected function timerHandler(_arg1:TimerEvent):void{
			this.nextFrame();
			_arg1.updateAfterEvent();
		}
		public function get FPS():Number{
			return (this._fps);
		}
		public function rewind(_arg1:Number=0):void{
			this._time = _arg1;
			this.fixTime();
			this.update();
		}
		public function set position(_arg1:Number):void{
			this.setPosition(_arg1);
		}
		public function get time():Number{
			return (this._time);
		}
		private function update():void{
			this.setPosition(this.getPosition(this._time));
		}
		public function start():void{
			this.rewind();
			this.startEnterFrame();
			this.dispatchEvent(new TweenEvent(TweenEvent.MOTION_START, this._time, this._position));
		}
		public function prevFrame():void{
			if (!this.useSeconds){
				this.time = (this._time - 1);
			};
		}

	}
}//package fl.transitions 
Section 13
//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_LOOP:String = "motionLoop";
		public static const MOTION_CHANGE:String = "motionChange";
		public static const MOTION_FINISH:String = "motionFinish";
		public static const MOTION_RESUME:String = "motionResume";

		public function TweenEvent(_arg1:String, _arg2:Number, _arg3:Number, _arg4:Boolean=false, _arg5:Boolean=false){
			time = NaN;
			position = NaN;
			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 14
//FiniteStateMachine (ndi.ai.FiniteStateMachine)
package ndi.ai {
	import ndi.logger.*;

	public class FiniteStateMachine {

		private var m_currentState:IFSMState;
		private var m_OwnerName:String;

		static var c_TracePublisher:LoggerTracePublisher = new LoggerTracePublisher();
		static var c_fsmLogger:Logger = new Logger("fsmLogger");

		public function FiniteStateMachine(_arg1:String, _arg2:IFSMState){
			m_OwnerName = _arg1;
			c_fsmLogger.debug((("FSM for " + m_OwnerName) + " initialized"));
			m_currentState = _arg2;
			c_fsmLogger.debug(((m_OwnerName + " ENTERING STATE: ") + m_currentState));
			m_currentState.enter();
		}
		private function _enterState(_arg1:IFSMState):void{
			if (_arg1 == null){
				c_fsmLogger.error((m_OwnerName + " ENTERING null STATE"));
			};
			m_currentState = _arg1;
			c_fsmLogger.debug(((m_OwnerName + " ENTERING STATE: ") + _arg1));
			m_currentState.enter();
		}
		public function ChangeState(_arg1:IFSMState, _arg2:Boolean=false):void{
			if (((_arg2) || (!((_arg1 == m_currentState))))){
				_exitState();
				_enterState(_arg1);
			};
		}
		public function Update(_arg1:Number):void{
			if (m_currentState){
				m_currentState.update(_arg1);
			};
		}
		public function set currentState(_arg1:IFSMState):void{
			m_currentState = _arg1;
		}
		public function get currentState():IFSMState{
			return (m_currentState);
		}
		public function destroy():void{
			if (m_currentState){
				m_currentState = null;
			};
		}
		private function _exitState():void{
			c_fsmLogger.debug(((m_OwnerName + " EXITING STATE: ") + m_currentState));
			m_currentState.exit();
		}

		c_fsmLogger.addPublisher(c_TracePublisher);
	}
}//package ndi.ai 
Section 15
//IFSMState (ndi.ai.IFSMState)
package ndi.ai {

	public interface IFSMState {

		function enter():void;
		function update(_arg1:Number):void;
		function toString():String;
		function exit():void;

	}
}//package ndi.ai 
Section 16
//ILoggerPublisher (ndi.logger.ILoggerPublisher)
package ndi.logger {

	public interface ILoggerPublisher {

		function toString():String;
		function publish(_arg1:LoggerEvent):void;

	}
}//package ndi.logger 
Section 17
//Logger (ndi.logger.Logger)
package ndi.logger {

	public class Logger {

		private var m_filters:Array;
		private var m_level:LoggerLevel;
		private var m_publishers:Array;
		private var m_loggerId:String;

		public function Logger(_arg1:String){
			if (((_arg1) && ((_arg1.length > 0)))){
				m_loggerId = _arg1;
			};
			m_level = LoggerLevel.LOG;
			m_publishers = new Array();
			m_filters = new Array();
		}
		public function setLevel(_arg1:LoggerLevel):void{
			m_level = _arg1;
		}
		public function assert(_arg1:Boolean, _arg2, _arg3:Boolean=false):void{
			var _local4:Function;
			if (_arg1 == false){
				fatal(_arg2);
				if (_arg3 == true){
					_local4 = null;
					_local4();
				};
			};
		}
		public function error(_arg1):void{
			publish(_arg1, LoggerLevel.ERROR);
		}
		public function log(_arg1):void{
			publish(_arg1, LoggerLevel.LOG);
		}
		public function getPublishers():Array{
			return (m_publishers);
		}
		public function info(_arg1):void{
			publish(_arg1, LoggerLevel.INFO);
		}
		public function debug(_arg1):void{
			publish(_arg1, LoggerLevel.DEBUG);
		}
		private function publish(_arg1, _arg2:LoggerLevel):void{
			var _local3:LoggerEvent;
			var _local4:String;
			if (_arg2.getValue() >= m_level.getValue()){
				_local3 = new LoggerEvent(m_loggerId, _arg1, _arg2);
				for (_local4 in m_publishers) {
					ILoggerPublisher(m_publishers[_local4]).publish(_local3);
				};
			};
		}
		public function removePublisher(_arg1:ILoggerPublisher):void{
			delete m_publishers[_arg1.toString()];
		}
		public function addPublisher(_arg1:ILoggerPublisher):void{
			if (!m_publishers[_arg1.toString()]){
				m_publishers[_arg1.toString()] = _arg1;
			};
		}
		public function fatal(_arg1):void{
			publish(_arg1, LoggerLevel.FATAL);
		}
		public function warn(_arg1):void{
			publish(_arg1, LoggerLevel.WARN);
		}

	}
}//package ndi.logger 
Section 18
//LoggerEvent (ndi.logger.LoggerEvent)
package ndi.logger {

	public class LoggerEvent {

		private var m_loggerId:String;
		private var m_level:LoggerLevel;
		private var m_argument:Object;
		private var m_time:Date;

		public function LoggerEvent(_arg1:String, _arg2:Object, _arg3:LoggerLevel){
			m_loggerId = _arg1;
			m_argument = _arg2;
			m_level = _arg3;
			m_time = new Date();
		}
		function get loggerId():String{
			return (m_loggerId);
		}
		function get time():Date{
			return (m_time);
		}
		function get level():LoggerLevel{
			return (m_level);
		}
		function get argument():Object{
			return (m_argument);
		}

		static function serialize(_arg1:LoggerEvent):Object{
			var _local2:Object;
			_local2 = new Object();
			_local2.loggerId = _arg1.loggerId;
			_local2.time = _arg1.time;
			_local2.levelName = _arg1.m_level.getName();
			_local2.argument = _arg1.argument;
			return (_local2);
		}
		static function deserialize(_arg1:Object):LoggerEvent{
			var _local2:LoggerLevel;
			var _local3:LoggerEvent;
			_local2 = LoggerLevel[("" + _arg1.m_levelName)];
			_local3 = new LoggerEvent(_arg1.m_loggerId, _arg1.m_argument, _local2);
			_local3.m_time = _arg1.m_time;
			return (_local3);
		}

	}
}//package ndi.logger 
Section 19
//LoggerLevel (ndi.logger.LoggerLevel)
package ndi.logger {

	public class LoggerLevel {

		private var m_name:String;
		private var m_value:Number;

		static const ALL:LoggerLevel = new LoggerLevel("ALL", 1);
;
		static const LOG:LoggerLevel = new LoggerLevel("LOG", 1);
;
		static const WARN:LoggerLevel = new LoggerLevel("WARN", 8);
;
		static const INFO:LoggerLevel = new LoggerLevel("INFO", 4);
;
		static const ERROR:LoggerLevel = new LoggerLevel("ERROR", 16);
;
		static const FATAL:LoggerLevel = new LoggerLevel("FATAL", 32);
;
		static const DEBUG:LoggerLevel = new LoggerLevel("DEBUG", 2);
;
		static const NONE:LoggerLevel = new LoggerLevel("NONE", 0x0400);
;

		private static var c_enumCreated:Boolean = false;

		public function LoggerLevel(_arg1:String, _arg2:Number){
			if (c_enumCreated){
				throw (new Error("MyEnum -> The enum is already created."));
			};
			m_name = _arg1;
			m_value = _arg2;
		}
		function getName():String{
			return (m_name);
		}
		function getValue():Number{
			return (m_value);
		}
		function toString():String{
			return (getName());
		}

		c_enumCreated = true;
	}
}//package ndi.logger 
Section 20
//LoggerTracePublisher (ndi.logger.LoggerTracePublisher)
package ndi.logger {
	import flash.display.*;

	public class LoggerTracePublisher implements ILoggerPublisher {

		private var m_maxDepth:Number;

		public function LoggerTracePublisher(){
			m_maxDepth = 4;
		}
		private function multiply(_arg1:String, _arg2:Number):String{
			var _local3:String;
			var _local4:Number;
			_local3 = "";
			_local4 = 0;
			while (_local4 < _arg2) {
				_local3 = (_local3 + _arg1);
				_local4++;
			};
			return (_local3);
		}
		private function analyzeObj(_arg1, _arg2:Number):String{
			var _local3:String;
			var _local4:String;
			var _local5:Boolean;
			var _local6:Boolean;
			var _local7:String;
			var _local8:*;
			_local3 = "";
			_local4 = typeof(_arg1);
			if (_local4 == "string"){
				_local3 = (_local3 + (("\"" + _arg1) + "\""));
			} else {
				if ((((_local4 == "boolean")) || ((_local4 == "number")))){
					_local3 = (_local3 + _arg1);
				} else {
					if ((((_local4 == "undefined")) || ((_local4 == "null")))){
						_local3 = (_local3 + (("(" + _local4) + ")"));
					} else {
						_local5 = false;
						_local6 = true;
						if ((_arg1 is Array)){
							_local4 = "Array";
							_local5 = false;
						} else {
							if ((_arg1 is Date)){
								_local4 = "Date";
								_local6 = false;
								_local5 = true;
							} else {
								if ((_arg1 is Sprite)){
									if ((_arg1 is MovieClip)){
										_local4 = "MovieClip";
									} else {
										_local4 = "Sprite";
									};
									_local6 = true;
									_local5 = true;
								} else {
									if ((_arg1 is BitmapData)){
										_local4 = "BitmapData";
										_local6 = true;
										_local5 = true;
									} else {
										if ((_arg1 is Bitmap)){
											_local4 = "Bitmap";
											_local6 = true;
											_local5 = true;
										};
									};
								};
							};
						};
						_local3 = (_local3 + (("(" + _local4) + ") "));
						if (_local5){
							_local3 = (_local3 + _arg1.toString());
						};
						if (((_local6) && ((_arg2 <= m_maxDepth)))){
							_local7 = "";
							for (_local8 in _arg1) {
								_local7 = (_local7 + (((("\n" + multiply("\t", (_arg2 + 1))) + _local8) + ":") + analyzeObj(_arg1[_local8], (_arg2 + 1))));
							};
							if (_local7.length > 0){
								_local3 = (_local3 + (((("{" + _local7) + "\n") + multiply("\t", _arg2)) + "}"));
							};
						};
					};
				};
			};
			return (_local3);
		}
		public function publish(_arg1:LoggerEvent):void{
			var _local2:Object;
			var _local3:String;
			_local2 = _arg1.argument;
			_local3 = (("*" + _arg1.level.toString()) + "*");
			if (_arg1.loggerId){
				_local3 = (_local3 + (":" + _arg1.loggerId));
			};
			_local3 = (_local3 + ":");
			_local3 = (_local3 + analyzeObj(_local2, 1));
		}
		public function toString():String{
			return ("LoggerTracePublisher");
		}
		function set maxDepth(_arg1:Number):void{
			m_maxDepth = ((m_maxDepth)>0xFF) ? 0xFF : _arg1;
		}
		function get maxDepth():Number{
			return (m_maxDepth);
		}

	}
}//package ndi.logger 
Section 21
//Config (peach.config.Config)
package peach.config {
	import flash.events.*;
	import peach.events.*;
	import flash.net.*;
	import flash.utils.*;

	public dynamic class Config extends Proxy implements IEventDispatcher {

		private var m_eventDispatcher:EventDispatcher;
		private var m_loader:URLLoader;
		private var m_tempSettings:Array;
		private var m_settings:Object;

		public function Config(){
			m_eventDispatcher = new EventDispatcher();
			m_settings = new Object();
		}
		public function dispatchEvent(_arg1:Event):Boolean{
			return (m_eventDispatcher.dispatchEvent(_arg1));
		}
		public function willTrigger(_arg1:String):Boolean{
			return (m_eventDispatcher.willTrigger(_arg1));
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function getProperty(_arg1){
			if (!m_settings[_arg1]){
				throw (new Error(("peach.config.Config -> no setting found at key " + _arg1)));
			};
			return (m_settings[_arg1]);
		}
		public function addEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false, _arg4:int=0, _arg5:Boolean=false):void{
			m_eventDispatcher.addEventListener(_arg1, _arg2, _arg3, _arg4, _arg5);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function hasProperty(_arg1):Boolean{
			return (!((m_settings[_arg1] === undefined)));
		}
		public function removeEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false):void{
			m_eventDispatcher.removeEventListener(_arg1, _arg2, _arg3);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function callProperty(_arg1, ... _args){
			return (this[String(_arg1)].apply(_args));
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextNameIndex(_arg1:int):int{
			var _local2:*;
			if (_arg1 == 0){
				m_tempSettings = new Array();
				for (_local2 in m_settings) {
					m_tempSettings.push(_local2);
				};
			};
			return (((_arg1)<m_tempSettings.length) ? (_arg1 + 1) : 0);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function setProperty(_arg1, _arg2):void{
			var _local3:String;
			var _local4:SettingEvent;
			_local3 = (hasOwnProperty(_arg1)) ? SettingEvent.CHANGE : SettingEvent.ADD;
			_local4 = new SettingEvent(_local3, true, true);
			if (_local3 == SettingEvent.CHANGE){
				m_settings[_arg1].value = _arg2;
			} else {
				if (_local3 == SettingEvent.ADD){
					m_settings[_arg1] = new Setting(_arg1, _arg2);
				};
			};
			dispatchEvent(_local4);
		}
		public function clear():void{
			m_settings = new Object();
			dispatchEvent(new SettingEvent(SettingEvent.CLEAR, true, true));
		}
		private function _parseSettingsFromXml(_arg1:XML):void{
			var _local2:SharedObject;
			var _local3:*;
			var _local4:XML;
			var _local5:Array;
			_local2 = SharedObject.getLocal(Setting.SHARED_OBJECT_ID);
			for each (_local4 in _arg1.add) {
				switch (_local4.@type.toLowerCase()){
					case Setting.BOOLEAN:
						_local3 = ((((_local4.@value.toLowerCase() == "true")) || ((_local4.@value.toLowerCase() == "1")))) ? true : false;
						break;
					case Setting.INT:
						_local3 = int(_local4.@value);
						break;
					case Setting.NUMBER:
						_local3 = Number(_local4.@value);
						break;
					case Setting.RANGE:
						_local5 = _local4.@value.split("|");
						if (((isNaN(Number(_local5[0]))) || (isNaN(Number(_local5[1]))))){
							throw (new Error("Settings of type Setting.RANGE are expected to be two numbers, separated by a | (pipe)."));
						};
						_local3 = new Array(Number(_local5[0]), Number(_local5[1]));
						break;
					case Setting.UINT:
						_local3 = Math.abs(int(_local4.@value));
						break;
					case Setting.ARRAY:
						_local3 = _local4.@value.split("|");
						break;
					case Setting.STRING:
					default:
						_local3 = _local4.@value;
						break;
				};
				m_settings[_local4.@key] = new Setting(_local4.@key, _local3);
				if (_local2.data[_local4.@key] != undefined){
					this[_local4.@key] = _local2.data[_local4.@key];
				};
			};
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextName(_arg1:int):String{
			var _local2:int;
			var _local3:String;
			var _local4:*;
			_local2 = 1;
			_local3 = "";
			for (_local4 in m_settings) {
				if (_local2 == _arg1){
					_local3 = _local4;
					break;
				};
				_local2++;
			};
			return (_local3);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function deleteProperty(_arg1):Boolean{
			var _local2:Setting;
			_local2 = m_settings[_arg1];
			delete m_settings[_arg1];
			if (!hasOwnProperty(_arg1)){
				dispatchEvent(new SettingEvent(SettingEvent.DELETE, true, true));
			};
			return (!(hasOwnProperty(_arg1)));
		}
		private function _xmlLoaderComplete(_arg1:Event):void{
			_parseSettingsFromXml(XML(m_loader.data));
			dispatchEvent(new SettingEvent(SettingEvent.LOAD, true, true));
		}
		public function load(_arg1):void{
			if ((_arg1 is String)){
				_loadFromFile(_arg1);
			} else {
				if ((_arg1 is XML)){
					_parseSettingsFromXml(_arg1);
				};
			};
		}
		private function _loadFromFile(_arg1:String):void{
			var _local2:URLRequest;
			_local2 = new URLRequest(_arg1);
			m_loader = new URLLoader();
			m_loader.addEventListener(Event.COMPLETE, _xmlLoaderComplete);
			m_loader.load(_local2);
		}
		public function hasEventListener(_arg1:String):Boolean{
			return (m_eventDispatcher.hasEventListener(_arg1));
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextValue(_arg1:int){
			var _local2:int;
			var _local3:*;
			var _local4:*;
			_local2 = 1;
			for each (_local4 in m_settings) {
				if (_local2 == _arg1){
					_local3 = _local4;
					break;
				};
				_local2++;
			};
			return (_local3);
		}

	}
}//package peach.config 
Section 22
//GameSettings (peach.config.GameSettings)
package peach.config {
	import flash.utils.*;

	public dynamic class GameSettings extends Config {

		private static var c_instances:Dictionary;

		public function GameSettings(_arg1:SingletonEnforcer){
			if (_arg1 != null){
				super();
			} else {
				throw (new Error("The 'enforcer' argument for the AppSettings' constructor cannot be 'null' or 'undefined'"));
			};
		}
		public static function getInstance(_arg1:String):GameSettings{
			if (GameSettings.c_instances == null){
				GameSettings.c_instances = new Dictionary();
			};
			if (GameSettings.c_instances[_arg1] == null){
				GameSettings.c_instances[_arg1] = new GameSettings(new SingletonEnforcer());
			};
			return (GameSettings.c_instances[_arg1]);
		}

	}
}//package peach.config 

class SingletonEnforcer {

	private function SingletonEnforcer(){
	}
}
Section 23
//Setting (peach.config.Setting)
package peach.config {
	import flash.events.*;
	import peach.events.*;
	import flash.net.*;

	public class Setting extends EventDispatcher {

		private var m_defaultValue;
		private var m_id:String;
		private var m_value;

		public static const SHARED_OBJECT_ID:String = "setting";
		public static const BOOLEAN:String = "boolean";
		public static const INT:String = "int";
		public static const STRING:String = "string";
		public static const NUMBER:String = "number";
		public static const ARRAY:String = "array";
		public static const UINT:String = "uint";
		public static const RANGE:String = "range";

		public function Setting(_arg1:String, _arg2){
			m_id = _arg1;
			m_defaultValue = _arg2;
			m_value = _arg2;
		}
		public function set value(_arg1):void{
			var _local2:SettingEvent;
			if (m_value){
				_local2 = new SettingEvent(SettingEvent.CHANGE);
			} else {
				_local2 = new SettingEvent(SettingEvent.ADD);
			};
			m_value = _arg1;
			save();
			dispatchEvent(_local2);
		}
		public function reset():void{
			var _local1:SettingEvent;
			m_value = m_defaultValue;
			_local1 = new SettingEvent(SettingEvent.CHANGE);
			dispatchEvent(_local1);
		}
		public function get value(){
			return (m_value);
		}
		public function save():void{
			var _local1:SharedObject;
			_local1 = SharedObject.getLocal(SHARED_OBJECT_ID);
			_local1.data[m_id] = m_value;
			_local1.flush();
		}

	}
}//package peach.config 
Section 24
//AssetsLibrary (peach.core.AssetsLibrary)
package peach.core {
	import flash.events.*;
	import peach.events.*;
	import br.com.stimuli.loading.*;
	import flash.utils.*;

	public class AssetsLibrary extends EventDispatcher {

		private var m_assetsList:XML;
		private var m_id:String;
		private var m_loaders:Dictionary;

		private static var c_libraries:Dictionary;

		public function AssetsLibrary(_arg1:String, _arg2:XML){
			m_id = _arg1;
			m_assetsList = _arg2;
			m_loaders = new Dictionary();
		}
		public function loadNode(_arg1:String):void{
			var uri:String;
			var list:XMLList;
			var file:XML;
			var nodeName = _arg1;
			if (m_assetsList.node.(@name == nodeName) == null){
				throw (new Error((((("AssetsLibrary::loadNode -> no node with name \"" + nodeName) + "\" was found in \"") + m_id) + "\".")));
			};
			m_loaders[nodeName] = new AssetsNode(((m_id + ".") + nodeName));
			list = m_assetsList.node.(@name == nodeName).file;
			for each (file in list) {
				uri = ((file.path.toString() + "/") + file.name.toString());
				m_loaders[nodeName].add(uri, {id:uri, weight:Number(file.weight.toString())});
			};
			m_loaders[nodeName].addEventListener(BulkProgressEvent.PROGRESS, _onLoadProgress);
			m_loaders[nodeName].addEventListener(BulkProgressEvent.COMPLETE, _onNodeLoadComplete);
			m_loaders[nodeName].start();
		}
		public function clear():void{
			throw (new Error("AssetsLibrary::clear() not yet implemented."));
		}
		private function _onLoadProgress(_arg1:BulkProgressEvent):void{
			var _local2:Number;
			var _local3:AssetsLibraryEvent;
			_local2 = 0;
			if (((_arg1.bytesLoaded) && (_arg1.bytesTotal))){
				_local2 = (_arg1.bytesLoaded / _arg1.bytesTotal);
			};
			_local3 = new AssetsLibraryEvent(AssetsLibraryEvent.PROGRESS, _local2, _arg1.target._id);
			dispatchEvent(_local3);
		}
		public function isNodeLoaded(_arg1:String):Boolean{
			return (m_loaders[_arg1].IsFinished);
		}
		public function removeNode(_arg1:String):void{
			var _local2:AssetsNode;
			if ((m_loaders[_arg1] is AssetsNode)){
				_local2 = m_loaders[_arg1];
				_local2.clear();
				m_loaders[_arg1] = null;
			};
		}
		public function getNode(_arg1:String):AssetsNode{
			return (m_loaders[_arg1]);
		}
		private function _onNodeLoadComplete(_arg1:BulkProgressEvent):void{
			var _local2:AssetsLibraryEvent;
			_local2 = new AssetsLibraryEvent(AssetsLibraryEvent.NODE_COMPLETE, _arg1._percentLoaded, _arg1.target._id);
			dispatchEvent(_local2);
		}

		public static function getLibrary(_arg1:String):AssetsLibrary{
			return (c_libraries[_arg1]);
		}
		public static function createLibrary(_arg1:String, _arg2:XML):AssetsLibrary{
			var _local3:AssetsLibrary;
			_local3 = new AssetsLibrary(_arg1, _arg2);
			if (!c_libraries){
				c_libraries = new Dictionary();
			};
			c_libraries[_arg1] = _local3;
			return (_local3);
		}

	}
	var _local1:* = AssetsNode;
	return (_local1);
}//package peach.core 
Section 25
//AssetsNode (peach.core.AssetsNode)
package peach.core {
	import br.com.stimuli.loading.*;

	public class AssetsNode extends BulkLoader {

		public function AssetsNode(_arg1:String, _arg2:int=7, _arg3:int=20){
			super(_arg1, _arg2, _arg3);
		}
	}
}//package peach.core 
Section 26
//Bootstrap (peach.core.Bootstrap)
package peach.core {
	import flash.events.*;
	import peach.events.*;
	import flash.net.*;
	import peach.config.*;

	public class Bootstrap extends EventDispatcher {

		private var m_isConfigLoaded:Boolean;
		private var m_config:Config;
		private var m_gameID:String;
		private var m_requiredAssetsPercent:Number;
		private var m_defaultBasePath:String;
		private var m_initParameters:Object;
		private var m_isGameSettingsLoaded:Boolean;

		private static const AUTOSTART_DEFAULT:Boolean = true;
		private static const STAGE_WIDTH_DEFAULT:uint = 550;
		private static const PRELOADER_DEFAULT:String = "";
		private static const STAGE_HEIGHT_DEFAULT:uint = 400;
		private static const FILE_CACHING_DEFAULT:Boolean = true;

		public function Bootstrap(_arg1:Game){
			var _local2:String;
			var _local3:String;
			var _local4:int;
			super();
			m_gameID = _arg1.id;
			_local3 = _arg1.loaderInfo.url;
			_local4 = _local3.lastIndexOf("/");
			if (_local4 == -1){
				_local4 = _local3.lastIndexOf("\\");
			};
			m_defaultBasePath = _local3.substr(0, _local4);
			m_isGameSettingsLoaded = false;
			GameSettings.getInstance(m_gameID).load(((m_defaultBasePath + "/config/settings.xml?nocache=") + Math.round((Math.random() * 1000000))));
			GameSettings.getInstance(m_gameID).addEventListener(SettingEvent.LOAD, _onGameSettingsLoaded);
			m_isConfigLoaded = false;
			m_config = new Config();
			m_config.load(((m_defaultBasePath + "/ini.xml?nocache=") + Math.round((Math.random() * 1000000))));
			m_config.addEventListener(SettingEvent.LOAD, _onConfigLoaded);
		}
		private function _onConfigLoaded(_arg1:SettingEvent):void{
			var _local2:BootstrapEvent;
			var _local3:uint;
			var _local4:uint;
			var _local5:Boolean;
			var _local6:String;
			var _local7:Boolean;
			var _local8:String;
			var _local9:String;
			var _local10:URLLoader;
			_local3 = ((m_config.stageWidth.value)==null) ? STAGE_WIDTH_DEFAULT : m_config.stageWidth.value;
			_local4 = ((m_config.stageHeight.value)==null) ? STAGE_HEIGHT_DEFAULT : m_config.stageHeight.value;
			_local5 = ((m_config.autoStart.value)==null) ? AUTOSTART_DEFAULT : m_config.autoStart.value;
			_local6 = m_config.basePath.value;
			_local7 = ((m_config.fileCaching.value)==null) ? AUTOSTART_DEFAULT : m_config.fileCaching.value;
			_local8 = ((((m_config.preloader.value == null)) || ((m_config.preloader.value == "")))) ? PRELOADER_DEFAULT : m_config.preloader.value;
			if ((((_local6 == "")) || ((_local6 == null)))){
				_local6 = m_defaultBasePath;
			};
			m_config.removeEventListener(SettingEvent.LOAD, _onConfigLoaded);
			m_initParameters = {};
			m_initParameters.stageWidth = _local3;
			m_initParameters.stageHeight = _local4;
			m_initParameters.autoStart = _local5;
			m_initParameters.basePath = _local6;
			m_initParameters.fileCaching = _local7;
			m_initParameters.preloaderURL = _local8;
			_local9 = (m_initParameters.fileCaching) ? ((m_initParameters.basePath + "/config/assets.xml?nocache=") + Math.round((Math.random() * 1000000))) : (m_initParameters.basePath + "/config/assets.xml");
			_local10 = new URLLoader(new URLRequest(_local9));
			_local10.addEventListener(Event.COMPLETE, _onAssetsListLoad);
			m_isConfigLoaded = true;
			_verifyInit();
		}
		private function _verifyInit():void{
			var _local1:BootstrapEvent;
			if ((((m_isGameSettingsLoaded == true)) && ((m_isConfigLoaded == true)))){
				_local1 = new BootstrapEvent(BootstrapEvent.INIT);
				dispatchEvent(_local1);
			};
		}
		private function _onAssetsComplete(_arg1:AssetsLibraryEvent):void{
			var _local2:BootstrapEvent;
			_local2 = new BootstrapEvent(BootstrapEvent.REQUIRED_ASSETS_LOAD_COMPLETE);
			dispatchEvent(_local2);
		}
		public function get initParameters():Object{
			return (m_initParameters);
		}
		private function _onAssetsProgress(_arg1:AssetsLibraryEvent):void{
			var _local2:BootstrapEvent;
			_local2 = new BootstrapEvent(BootstrapEvent.REQUIRED_ASSETS_LOAD_PROGRESS);
			m_requiredAssetsPercent = _arg1.percentLoaded;
			dispatchEvent(_local2);
		}
		public function clear():void{
			m_config.clear();
			m_config = null;
		}
		private function _onGameSettingsLoaded(_arg1:SettingEvent):void{
			GameSettings.getInstance(m_gameID).removeEventListener(SettingEvent.LOAD, _onGameSettingsLoaded);
			m_isGameSettingsLoaded = true;
			_verifyInit();
		}
		public function get requiredAssetsPercentage():Number{
			return (m_requiredAssetsPercent);
		}
		private function _onAssetsListLoad(_arg1:Event):void{
			var _local2:AssetsLibrary;
			XML.ignoreWhitespace = true;
			XML.ignoreComments = true;
			_local2 = AssetsLibrary.createLibrary(m_gameID, new XML(URLLoader(_arg1.target).data));
			_local2.addEventListener(AssetsLibraryEvent.PROGRESS, _onAssetsProgress);
			_local2.addEventListener(AssetsLibraryEvent.NODE_COMPLETE, _onAssetsComplete);
			_local2.loadNode("startup");
		}

	}
}//package peach.core 
Section 27
//Game (peach.core.Game)
package peach.core {
	import flash.events.*;
	import flash.display.*;
	import peach.events.*;
	import flash.net.*;
	import peach.config.*;

	public class Game extends MovieClip {

		private var m_stageHeight:uint;
		private var m_bootstrap:Bootstrap;
		private var m_id:String;
		protected var preloaderView:MovieClip;
		private var m_basePath:String;
		private var m_autoStart:Boolean;
		private var m_stageWidth:uint;
		private var m_preloaderURL:String;
		private var m_fileCaching:Boolean;

		public static const ASSET_TYPE_XML:String = "assetTypeXml";
		public static const ASSET_TYPE_SOUND:String = "assetTypeSound";
		public static const ASSET_TYPE_SWF:String = "assetTypeSwf";

		public function Game(_arg1:String){
			m_id = _arg1;
			m_bootstrap = new Bootstrap(this);
			m_bootstrap.addEventListener(BootstrapEvent.INIT, _onBootstrapInit);
			m_bootstrap.addEventListener(BootstrapEvent.REQUIRED_ASSETS_LOAD_PROGRESS, _onRequiredAssetsProgress);
			m_bootstrap.addEventListener(BootstrapEvent.REQUIRED_ASSETS_LOAD_COMPLETE, _onRequiredAssetsComplete);
		}
		public function init(_arg1:uint, _arg2:uint, _arg3:Boolean, _arg4:String, _arg5:Boolean, _arg6:String):void{
			var _local7:Loader;
			var _local8:URLRequest;
			m_stageWidth = _arg1;
			m_stageHeight = _arg2;
			m_autoStart = _arg3;
			m_basePath = _arg4;
			m_fileCaching = _arg5;
			m_preloaderURL = _arg6;
			if (m_preloaderURL != ""){
				_local7 = new Loader();
				_local8 = new URLRequest(((m_basePath + "/assets/") + m_preloaderURL));
				_local7.contentLoaderInfo.addEventListener(Event.COMPLETE, _onPreloaderLoad);
				_local7.load(_local8);
			};
		}
		public function get id():String{
			return (m_id);
		}
		private function _onRequiredAssetsProgress(_arg1:BootstrapEvent):void{
			if (preloaderView != null){
				preloaderView.gotoAndStop(Math.ceil((m_bootstrap.requiredAssetsPercentage * 100)));
			};
		}
		public function start():void{
			throw (new Error("Please override Game::start()"));
		}
		public function GetAsset(_arg1:String, _arg2:String, _arg3:Boolean=false):Object{
			var _local4:AssetsNode;
			var _local5:Object;
			_local4 = AssetsLibrary.getLibrary(id).getNode("startup");
			switch (_arg1){
				case ASSET_TYPE_SWF:
					_local5 = _local4.getMovieClip(_arg2, _arg3);
					break;
				case ASSET_TYPE_XML:
					_local5 = _local4.getXML(_arg2, _arg3);
					break;
				case ASSET_TYPE_SOUND:
					_local5 = _local4.getSound(_arg2, _arg3);
					break;
			};
			return (_local5);
		}
		public function GetSettings():GameSettings{
			return (GameSettings.getInstance(m_id));
		}
		private function _onRequiredAssetsComplete(_arg1:BootstrapEvent):void{
			m_bootstrap.removeEventListener(BootstrapEvent.INIT, _onBootstrapInit);
			m_bootstrap.removeEventListener(BootstrapEvent.REQUIRED_ASSETS_LOAD_PROGRESS, _onRequiredAssetsProgress);
			m_bootstrap.removeEventListener(BootstrapEvent.REQUIRED_ASSETS_LOAD_COMPLETE, _onRequiredAssetsComplete);
			m_bootstrap.clear();
			m_bootstrap = null;
			start();
		}
		private function _onPreloaderLoad(_arg1:Event):void{
			preloaderView = (_arg1.target.content as MovieClip);
			this.addChild(preloaderView);
		}
		private function _onBootstrapInit(_arg1:BootstrapEvent):void{
			var _local2:Object;
			_local2 = m_bootstrap.initParameters;
			init(_local2.stageWidth, _local2.stageHeight, _local2.autoStart, _local2.basePath, _local2.fileCaching, _local2.preloaderURL);
		}

	}
}//package peach.core 
Section 28
//AssetsLibraryEvent (peach.events.AssetsLibraryEvent)
package peach.events {
	import flash.events.*;

	public class AssetsLibraryEvent extends Event {

		private var m_percentLoaded:Number;
		private var m_nodeName:String;

		public static const NODE_COMPLETE:String = "AssetsLibraryEvent_nodeComplete";
		public static const COMPLETE:String = "AssetsLibraryEvent_complete";
		public static const PROGRESS:String = "AssetsLibraryEvent_progress";

		public function AssetsLibraryEvent(_arg1:String, _arg2:Number, _arg3:String=null){
			super(_arg1);
			m_percentLoaded = _arg2;
			m_nodeName = _arg3;
		}
		public function get percentLoaded():Number{
			return (m_percentLoaded);
		}
		public function get nodeName():String{
			return (m_nodeName);
		}

	}
}//package peach.events 
Section 29
//BootstrapEvent (peach.events.BootstrapEvent)
package peach.events {
	import flash.events.*;

	public class BootstrapEvent extends Event {

		public static const INIT:String = "BootstrapEvent_init";
		public static const REQUIRED_ASSETS_LOAD_PROGRESS:String = "BootstrapEvent_requiredAssetsLoadProgress";
		public static const REQUIRED_ASSETS_LOAD_COMPLETE:String = "BootstrapEvent_requiredAssetsLoadComplete";
		public static const REQUIRED_ASSETS_LOAD_INIT:String = "BootstrapEvent_requiredAssetsLoadInit";

		public function BootstrapEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
		}
	}
}//package peach.events 
Section 30
//SettingEvent (peach.events.SettingEvent)
package peach.events {
	import flash.events.*;

	public class SettingEvent extends Event {

		public static const CHANGE:String = "Setting_change";
		public static const ADD:String = "Setting_create";
		public static const LOAD:String = "Setting_load";
		public static const DELETE:String = "Setting_delete";
		public static const CLEAR:String = "Setting_clear";

		public function SettingEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
		}
	}
}//package peach.events 
Section 31
//Character (qbert.data.Character)
package qbert.data {
	import flash.events.*;
	import ndi.ai.*;

	public class Character extends EventDispatcher {

		protected var m_charName:String;
		protected var m_tile:HexTile;
		protected var m_isMoving:Boolean;
		protected var m_fsm:FiniteStateMachine;

		public function Character(_arg1:String, _arg2:HexTile){
			m_charName = _arg1;
			m_tile = _arg2;
			m_fsm = null;
			m_isMoving = false;
		}
		public function get charName():String{
			return (m_charName);
		}
		public function get isMoving():Boolean{
			return (m_isMoving);
		}
		public function set tile(_arg1:HexTile):void{
			m_tile = _arg1;
		}
		public function get tile():HexTile{
			return (m_tile);
		}
		public function set isMoving(_arg1:Boolean):void{
			m_isMoving = _arg1;
		}
		public function get stateMachine():FiniteStateMachine{
			return (m_fsm);
		}

	}
}//package qbert.data 
Section 32
//HexTile (qbert.data.HexTile)
package qbert.data {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;

	public class HexTile extends EventDispatcher {

		private var m_hasPickUp:Boolean;
		private var m_isReserved:Boolean;
		private var m_dangerType:uint;
		private var m_adjacentHexTiles:Dictionary;
		private var m_pickUpType:uint;
		private var m_relativeAdjPos:String;
		private var m_id:uint;
		private var m_occupied:Boolean;
		private var m_view:MovieClip;
		private var m_state:uint;
		private var m_warning:MovieClip;
		private var m_hitzone:MovieClip;
		private var m_targetTile:HexTile;
		private var m_isDangerous:Boolean;

		public static const TILE_ROLLOUT:String = "hextile_tile_rollout";
		public static const TILE_ROLLOVER:String = "hextile_tile_rollover";
		public static const POS_UP:String = "hextile_pos_up";
		public static const POS_UPLEFT:String = "hextile_pos_upleft";
		public static const POS_DOWNRIGHT:String = "hextile_pos_downright";
		public static const POS_DOWN:String = "hextile_pos_down";
		public static const POS_UPRIGHT:String = "hextile_pos_upright";
		public static const TILE_CLICK:String = "hextile_tile_click";
		public static const POS_DOWNLEFT:String = "hextile_pos_downleft";

		public function HexTile(_arg1:uint, _arg2:MovieClip, _arg3:MovieClip, _arg4:Boolean){
			m_id = _arg1;
			m_hitzone = _arg2;
			m_hitzone.stop();
			m_hitzone.addEventListener(MouseEvent.MOUSE_MOVE, _onTileRollOver);
			m_hitzone.addEventListener(MouseEvent.ROLL_OUT, _onTileRollOut);
			m_hitzone.addEventListener(MouseEvent.CLICK, _onTileClick);
			m_view = _arg3;
			if (m_view.alpha != 1){
				m_view.alpha = 0;
			};
			if (_arg4){
				m_view.addEventListener(Event.ENTER_FRAME, _onWarningMCReady);
			};
			m_state = 1;
			m_adjacentHexTiles = new Dictionary();
			m_occupied = false;
			m_isDangerous = false;
			m_hasPickUp = false;
			m_isReserved = false;
		}
		public function set isDangerous(_arg1:Boolean):void{
			m_isDangerous = _arg1;
		}
		public function set upRight(_arg1:HexTile):void{
			m_adjacentHexTiles["upright"] = _arg1;
		}
		public function get posY():Number{
			return ((m_view.y + m_view.parent.y));
		}
		public function set dangerType(_arg1:uint):void{
			m_dangerType = _arg1;
		}
		public function isAdjacent(_arg1:HexTile):Boolean{
			var _local2:Boolean;
			_local2 = false;
			m_targetTile = null;
			switch (_arg1){
				case upLeft:
					m_relativeAdjPos = POS_UPLEFT;
					_local2 = true;
					break;
				case up:
					m_relativeAdjPos = POS_UP;
					_local2 = true;
					break;
				case upRight:
					m_relativeAdjPos = POS_UPRIGHT;
					_local2 = true;
					break;
				case downRight:
					m_relativeAdjPos = POS_DOWNRIGHT;
					_local2 = true;
					break;
				case down:
					m_relativeAdjPos = POS_DOWN;
					_local2 = true;
					break;
				case downLeft:
					m_relativeAdjPos = POS_DOWNLEFT;
					_local2 = true;
					break;
				default:
					m_relativeAdjPos = null;
					break;
			};
			if (_local2){
				m_targetTile = _arg1;
			};
			return (_local2);
		}
		public function get state():uint{
			return (m_state);
		}
		public function set downLeft(_arg1:HexTile):void{
			m_adjacentHexTiles["downleft"] = _arg1;
		}
		public function get posX():Number{
			return ((m_view.x + m_view.parent.x));
		}
		public function get relativeAdjPos():String{
			return (m_relativeAdjPos);
		}
		public function get downRight():HexTile{
			return (m_adjacentHexTiles["downright"]);
		}
		public function get id():uint{
			return (m_id);
		}
		public function warning():void{
			if (m_warning){
				m_warning.gotoAndPlay(1);
				m_warning.alpha = 1;
			};
		}
		public function warningOver():void{
			if (m_warning){
				m_warning.alpha = 0;
			};
		}
		public function set state(_arg1:uint):void{
			m_state = _arg1;
			m_view.gotoAndStop(_arg1);
		}
		private function _onTileClick(_arg1:MouseEvent):void{
			var _local2:Event;
			_local2 = new Event(TILE_CLICK);
			this.dispatchEvent(_local2);
		}
		public function get adjacentHexTiles():Dictionary{
			return (m_adjacentHexTiles);
		}
		public function set upLeft(_arg1:HexTile):void{
			m_adjacentHexTiles["upleft"] = _arg1;
		}
		public function get down():HexTile{
			return (m_adjacentHexTiles["down"]);
		}
		public function get up():HexTile{
			return (m_adjacentHexTiles["up"]);
		}
		private function _onTileRollOut(_arg1:MouseEvent):void{
			var _local2:Event;
			_local2 = new Event(TILE_ROLLOUT);
			this.dispatchEvent(_local2);
		}
		private function _onWarningMCReady(_arg1:Event):void{
			var _local2:MovieClip;
			_local2 = (m_view.getChildByName("mc_warning") as MovieClip);
			if (_local2 != null){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWarningMCReady);
				m_warning = _local2;
				warningOver();
			};
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function set up(_arg1:HexTile):void{
			m_adjacentHexTiles["up"] = _arg1;
		}
		public function set downRight(_arg1:HexTile):void{
			m_adjacentHexTiles["downright"] = _arg1;
		}
		public function get upRight():HexTile{
			return (m_adjacentHexTiles["upright"]);
		}
		public function get upLeft():HexTile{
			return (m_adjacentHexTiles["upleft"]);
		}
		public function isEmpty():Boolean{
			return (((((((!(m_occupied)) && (!(m_isDangerous)))) && (!(m_hasPickUp)))) && (!(m_isReserved))));
		}
		public function set down(_arg1:HexTile):void{
			m_adjacentHexTiles["down"] = _arg1;
		}
		public function get downLeft():HexTile{
			return (m_adjacentHexTiles["downleft"]);
		}
		public function get occupied():Boolean{
			return (m_occupied);
		}
		public function set hasPickUp(_arg1:Boolean):void{
			m_hasPickUp = _arg1;
		}
		public function get isDangerous():Boolean{
			return (m_isDangerous);
		}
		public function get viewX():Number{
			return (m_view.x);
		}
		public function get viewY():Number{
			return (m_view.y);
		}
		private function _onTileRollOver(_arg1:MouseEvent):void{
			var _local2:Event;
			_local2 = new Event(TILE_ROLLOVER);
			this.dispatchEvent(_local2);
		}
		public function set occupied(_arg1:Boolean):void{
			m_occupied = _arg1;
		}
		public function get targetTile():HexTile{
			return (m_targetTile);
		}
		public function set isReserved(_arg1:Boolean):void{
			m_isReserved = _arg1;
		}
		public function get hasPickUp():Boolean{
			return (m_hasPickUp);
		}
		override public function toString():String{
			return (this.state.toString());
		}
		public function get isReserved():Boolean{
			return (m_isReserved);
		}
		public function set pickUpType(_arg1:uint):void{
			m_pickUpType = _arg1;
		}
		public function get pickUpType():uint{
			return (m_pickUpType);
		}
		public function destroy():void{
			var _local1:Object;
			if (m_hitzone.hasEventListener(MouseEvent.MOUSE_MOVE)){
				m_hitzone.removeEventListener(MouseEvent.MOUSE_MOVE, _onTileRollOver);
				m_hitzone.removeEventListener(MouseEvent.ROLL_OUT, _onTileRollOut);
				m_hitzone.removeEventListener(MouseEvent.CLICK, _onTileClick);
			};
			m_hitzone = null;
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWarningMCReady);
			};
			for (_local1 in m_adjacentHexTiles) {
				m_adjacentHexTiles[_local1] = null;
			};
			m_adjacentHexTiles = null;
			m_targetTile = null;
		}
		public function get dangerType():uint{
			return (m_dangerType);
		}

	}
}//package qbert.data 
Section 33
//TileEvent (qbert.events.TileEvent)
package qbert.events {
	import flash.events.*;
	import qbert.data.*;

	public class TileEvent extends Event {

		private var m_edgeHexTile:HexTile;

		public static const EDGE_DETECTED:String = "tileevent_edge_detected";

		public function TileEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
		}
		public function get edgeHexTile():HexTile{
			return (m_edgeHexTile);
		}
		public function set edgeHexTile(_arg1:HexTile):void{
			m_edgeHexTile = _arg1;
		}

	}
}//package qbert.events 
Section 34
//TileManager (qbert.manager.TileManager)
package qbert.manager {
	import flash.events.*;
	import flash.display.*;
	import qbert.data.*;
	import qbert.events.*;

	public class TileManager extends EventDispatcher {

		private var m_tileHovered:HexTile;
		private var m_visualLayers:Array;
		private var m_tileClicked:HexTile;
		private var m_availableTiles:Array;
		private var m_isWarningAvailable:Boolean;
		private var m_hitzone:MovieClip;
		private var m_tiles:Array;
		private var m_width:uint;
		private var m_view:MovieClip;
		private var m_height:uint;

		public static const TILE_HOVERED:String = "tilemanager_tile_hovered";
		public static const TILE_CLICKED:String = "tilemanager_tile_clicked";

		public function TileManager(_arg1:MovieClip, _arg2:MovieClip, _arg3:uint, _arg4:uint, _arg5:Boolean){
			m_hitzone = _arg1;
			m_view = _arg2;
			m_width = _arg3;
			m_height = _arg4;
			m_isWarningAvailable = _arg5;
			m_visualLayers = new Array();
			m_tiles = new Array((m_width * m_height));
			m_availableTiles = new Array();
			m_tileHovered = null;
		}
		public function destroy():void{
			var _local1:HexTile;
			var _local2:uint;
			_local2 = 0;
			while (_local2 < m_availableTiles.length) {
				_local1 = getTile(m_availableTiles[_local2]);
				_local1.destroy();
				if (_local1.hasEventListener(HexTile.TILE_ROLLOVER)){
					_local1.removeEventListener(HexTile.TILE_ROLLOVER, _onHtRollOver);
					_local1.removeEventListener(HexTile.TILE_CLICK, _onHtClick);
				};
				m_tiles[_local2] = null;
				_local2++;
			};
			m_tiles = null;
			m_availableTiles = null;
			m_tileHovered = null;
			m_tileClicked = null;
			m_hitzone = null;
			m_view = null;
		}
		public function init():void{
			var _local1:MovieClip;
			var _local2:MovieClip;
			var _local3:HexTile;
			var _local4:uint;
			var _local5:TileEvent;
			_local4 = 0;
			while (_local4 < m_tiles.length) {
				_local1 = m_hitzone[(("t" + (_local4 + 1)) + "_mc")];
				_local2 = m_view[(("t" + (_local4 + 1)) + "_mc")];
				if (_local2 != null){
					_addVisualLayers(_local2.y);
					_local3 = new HexTile((_local4 + 1), _local1, _local2, m_isWarningAvailable);
					_local3.state = 1;
					_local3.addEventListener(HexTile.TILE_ROLLOVER, _onHtRollOver);
					_local3.addEventListener(HexTile.TILE_CLICK, _onHtClick);
					m_tiles[_local4] = _local3;
					if (_local2.alpha != 1){
						_local5 = new TileEvent(TileEvent.EDGE_DETECTED);
						_local5.edgeHexTile = _local3;
						this.dispatchEvent(_local5);
					} else {
						m_availableTiles.push((_local4 + 1));
					};
				};
				_local4++;
			};
			_setNeighbors();
		}
		private function _onHtRollOver(_arg1:Event):void{
			m_tileHovered = (_arg1.target as HexTile);
			this.dispatchEvent(new Event(TILE_HOVERED));
		}
		private function _setTargetHt(_arg1:HexTile, _arg2:String, _arg3:uint):void{
			var _local4:HexTile;
			_local4 = m_tiles[_arg3];
			if (_local4 != null){
				_arg1[_arg2] = (_local4 as HexTile);
			};
		}
		public function get tileClicked():HexTile{
			return (m_tileClicked);
		}
		private function _setNeighbors():void{
			var _local1:HexTile;
			var _local2:HexTile;
			var _local3:uint;
			var _local4:uint;
			_local4 = 0;
			while (_local4 < m_tiles.length) {
				_local1 = m_tiles[_local4];
				if (_local1 != null){
					_local3 = (Math.floor((_local4 / m_height)) + 1);
					if ((_local4 % m_height) != 0){
						_setTargetHt(_local1, "up", (_local4 - 1));
					};
					if ((_local4 % m_height) != (m_height - 1)){
						_setTargetHt(_local1, "down", (_local4 + 1));
					};
					if (_local4 >= m_height){
						if ((_local3 % 2) == 0){
							if ((_local4 % m_height) != 0){
								_setTargetHt(_local1, "upLeft", ((_local4 - m_height) - 1));
							};
							_setTargetHt(_local1, "downLeft", (_local4 - m_height));
						} else {
							if ((_local3 % 2) == 1){
								_setTargetHt(_local1, "upLeft", (_local4 - m_height));
								if ((_local4 % m_height) != (m_height - 1)){
									_setTargetHt(_local1, "downLeft", ((_local4 - m_height) + 1));
								};
							};
						};
					};
					if (_local4 < (m_tiles.length - m_height)){
						if ((_local3 % 2) == 0){
							if ((_local4 % m_height) != 0){
								_setTargetHt(_local1, "upRight", ((_local4 + m_height) - 1));
							};
							_setTargetHt(_local1, "downRight", (_local4 + m_height));
						} else {
							if ((_local3 % 2) == 1){
								_setTargetHt(_local1, "upRight", (_local4 + m_height));
								if ((_local4 % m_height) != (m_height - 1)){
									_setTargetHt(_local1, "downRight", ((_local4 + m_height) + 1));
								};
							};
						};
					};
				};
				_local4++;
			};
		}
		public function get numTiles():uint{
			return (m_availableTiles.length);
		}
		public function get tileHovered():HexTile{
			return (m_tileHovered);
		}
		public function get visualLayers():Array{
			return (m_visualLayers);
		}
		public function getTile(_arg1:uint):HexTile{
			var _local2:HexTile;
			_local2 = (m_tiles[(_arg1 - 1)] as HexTile);
			return (_local2);
		}
		public function getEmptyTile():HexTile{
			var _local1:uint;
			var _local2:uint;
			var _local3:HexTile;
			var _local4:uint;
			_local1 = 3;
			_local3 = null;
			_local4 = 0;
			while (_local4 < _local1) {
				_local2 = Math.floor((Math.random() * this.numTiles));
				_local3 = getTile(m_availableTiles[_local2]);
				if (_local3.isEmpty()){
					break;
				};
				_local3 = null;
				_local4++;
			};
			return (_local3);
		}
		private function _addVisualLayers(_arg1:Number):void{
			var _local2:int;
			var _local3:Boolean;
			var _local4:uint;
			_local2 = Math.floor(_arg1);
			_local3 = false;
			_local4 = 0;
			while (_local4 < m_visualLayers.length) {
				if (m_visualLayers[_local4] == _local2){
					_local3 = true;
				};
				_local4++;
			};
			if (!_local3){
				m_visualLayers.push(_local2);
			};
		}
		public function get availableTiles():Array{
			return (m_availableTiles);
		}
		private function _onHtClick(_arg1:Event):void{
			m_tileClicked = (_arg1.target as HexTile);
			this.dispatchEvent(new Event(TILE_CLICKED));
		}

	}
}//package qbert.manager 
Section 35
//bg_11 (Tweety_fla.bg_11)
package Tweety_fla {
	import flash.display.*;

	public dynamic class bg_11 extends MovieClip {

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

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

	public dynamic class bgs_8 extends MovieClip {

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

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

	public dynamic class BTN_STARTOVER_6 extends MovieClip {

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

	}
}//package Tweety_fla 
Section 38
//instructions_LVL2_9 (Tweety_fla.instructions_LVL2_9)
package Tweety_fla {
	import flash.display.*;
	import flash.text.*;

	public dynamic class instructions_LVL2_9 extends MovieClip {

		public var txt_numLevel:TextField;

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

	public dynamic class play_again_3 extends MovieClip {

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

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

	public dynamic class Point_txt_128 extends MovieClip {

		public var point_field:TextField;

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

	public dynamic class sound_on_off_28 extends MovieClip {

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

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

	public dynamic class tile_15 extends MovieClip {

		public var mc_warning:MovieClip;

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

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

	public dynamic class tile_disapear_22 extends MovieClip {

		public function tile_disapear_22(){
			addFrameScript(4, frame5);
		}
		function frame5(){
			stop();
		}

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

	public dynamic class tile_ins_59 extends MovieClip {

		public var mc_warning:MovieClip;

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

	public dynamic class tile_up_25 extends MovieClip {

		public function tile_up_25(){
			addFrameScript(17, frame18);
		}
		function frame18(){
			stop();
		}

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

	public dynamic class TileGrid_14 extends MovieClip {

		public var t56_mc:MovieClip;
		public var t22_mc:MovieClip;
		public var t62_mc:MovieClip;
		public var t39_mc:MovieClip;
		public var t45_mc:MovieClip;
		public var t85_mc:MovieClip;
		public var t51_mc:MovieClip;
		public var t79_mc:MovieClip;
		public var t28_mc:MovieClip;
		public var t68_mc:MovieClip;
		public var t40_mc:MovieClip;
		public var t80_mc:MovieClip;
		public var t34_mc:MovieClip;
		public var t5_mc:MovieClip;
		public var t23_mc:MovieClip;
		public var t63_mc:MovieClip;
		public var t46_mc:MovieClip;
		public var t86_mc:MovieClip;
		public var t52_mc:MovieClip;
		public var t12_mc:MovieClip;
		public var t29_mc:MovieClip;
		public var t35_mc:MovieClip;
		public var t69_mc:MovieClip;
		public var t6_mc:MovieClip;
		public var t18_mc:MovieClip;
		public var t58_mc:MovieClip;
		public var t24_mc:MovieClip;
		public var t64_mc:MovieClip;
		public var t30_mc:MovieClip;
		public var t70_mc:MovieClip;
		public var t47_mc:MovieClip;
		public var t53_mc:MovieClip;
		public var t13_mc:MovieClip;
		public var t87_mc:MovieClip;
		public var t76_mc:MovieClip;
		public var t42_mc:MovieClip;
		public var t36_mc:MovieClip;
		public var t7_mc:MovieClip;
		public var t19_mc:MovieClip;
		public var t31_mc:MovieClip;
		public var t59_mc:MovieClip;
		public var t71_mc:MovieClip;
		public var t48_mc:MovieClip;
		public var t54_mc:MovieClip;
		public var t20_mc:MovieClip;
		public var t14_mc:MovieClip;
		public var t60_mc:MovieClip;
		public var t37_mc:MovieClip;
		public var t43_mc:MovieClip;
		public var t77_mc:MovieClip;
		public var t26_mc:MovieClip;
		public var t66_mc:MovieClip;
		public var t32_mc:MovieClip;
		public var t49_mc:MovieClip;
		public var t15_mc:MovieClip;
		public var t72_mc:MovieClip;
		public var t55_mc:MovieClip;
		public var t21_mc:MovieClip;
		public var t61_mc:MovieClip;
		public var t38_mc:MovieClip;
		public var t44_mc:MovieClip;
		public var t78_mc:MovieClip;
		public var t50_mc:MovieClip;
		public var t27_mc:MovieClip;
		public var t67_mc:MovieClip;
		public var t33_mc:MovieClip;
		public var t16_mc:MovieClip;

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

	public dynamic class x_symbol_18 extends MovieClip {

		public function x_symbol_18(){
			addFrameScript(17, frame18);
		}
		function frame18(){
			stop();
		}

	}
}//package Tweety_fla 
Section 48
//DangerType (warnerbros.tweety.data.DangerType)
package warnerbros.tweety.data {

	public class DangerType {

		public static const HOLE:uint = 1;
		public static const SWIPE:uint = 2;
		public static const EDGE:uint = 3;

	}
}//package warnerbros.tweety.data 
Section 49
//HexTileState (warnerbros.tweety.data.HexTileState)
package warnerbros.tweety.data {

	public class HexTileState {

		public static const HOLE:uint = 4;
		public static const MESSY:uint = 1;
		public static const RECOVER:uint = 5;
		public static const COMPLETE:uint = 3;
		public static const ORDERLY:uint = 2;

	}
}//package warnerbros.tweety.data 
Section 50
//Pickup (warnerbros.tweety.data.Pickup)
package warnerbros.tweety.data {
	import warnerbros.tweety.*;
	import flash.events.*;
	import flash.display.*;

	public class Pickup extends EventDispatcher {

		private var m_type:uint;
		private var m_id:uint;
		private var m_disappearTimer:PauseableTimer;
		private var m_view:MovieClip;

		public static const DISAPPEAR_INTERVAL:uint = 5;
		public static const DISAPPEAR:String = "pickup_disappear";

		public function Pickup(_arg1:MovieClip, _arg2:uint){
			m_view = _arg1;
			m_type = _arg2;
			m_disappearTimer = new PauseableTimer((DISAPPEAR_INTERVAL * 1000));
			m_disappearTimer.callBackFc = _onDisappear;
		}
		private function _onDisappear():void{
			this.dispatchEvent(new Event(DISAPPEAR));
		}
		public function get type():uint{
			return (m_type);
		}
		public function appear():void{
			m_disappearTimer.start();
		}
		public function get id():uint{
			return (m_id);
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function set id(_arg1:uint):void{
			m_id = _arg1;
		}
		public function destroy():void{
			m_view = null;
			m_disappearTimer.pauseTimer(true);
			m_disappearTimer.destroy();
			m_disappearTimer = null;
		}

	}
}//package warnerbros.tweety.data 
Section 51
//PickupType (warnerbros.tweety.data.PickupType)
package warnerbros.tweety.data {

	public class PickupType {

		public static const BONUS1:uint = 1;
		public static const BONUS2:uint = 4;
		public static const BONUS3:uint = 5;
		public static const HAMMER_NAIL:uint = 3;
		public static const POW:uint = 2;

	}
}//package warnerbros.tweety.data 
Section 52
//Sylvester (warnerbros.tweety.data.Sylvester)
package warnerbros.tweety.data {
	import warnerbros.tweety.*;
	import flash.events.*;
	import flash.display.*;
	import ndi.ai.*;
	import warnerbros.tweety.states.*;
	import flash.utils.*;

	public class Sylvester extends EventDispatcher {

		private var mc_swipe1:MovieClip;
		private var mc_swipe2:MovieClip;
		private var mc_comeIn:MovieClip;
		private var m_currentSwipeView:MovieClip;
		private var m_gameMC:MovieClip;
		private var m_attackMode:uint;
		private var m_atkTimer:Timer;
		private var mc_peek2:MovieClip;
		private var mc_peek3:MovieClip;
		private var mc_peek4:MovieClip;
		private var mc_peek1:MovieClip;
		private var m_maxComeInInterval:Number;
		private var mc_hit:MovieClip;
		private var m_fsm:FiniteStateMachine;
		private var m_numConsecutiveSwipes:uint;
		private var mc_wait1:MovieClip;
		private var mc_wait2:MovieClip;
		private var m_comaInterval:Number;
		private var m_currentWaitView:MovieClip;
		private var m_maxAtkInterval:Number;
		private var m_charName:String;
		private var m_isSwiping:Boolean;
		private var m_comeInTimer:Timer;
		private var mc_hitSwiping:MovieClip;
		private var m_isHit:Boolean;
		private var m_minComeInInterval:Number;
		private var mc_leave:MovieClip;
		private var mc_idle:MovieClip;
		private var m_side:uint;
		private var m_waitInterval:Number;

		public static const COME_IN:String = "sylvester_come_in";
		public static const STATE_CHANGED:String = "sylvester_state_changed";
		public static const LEFT:uint = 1;
		public static const SWIPED:String = "sylvester_swiped";
		public static const MODE1:uint = 1;
		public static const MODE2:uint = 2;
		public static const SWIPE_WARNING:String = "sylvester_swipe_warning";
		public static const RIGHT:uint = 2;
		public static const LEAVE:String = "sylvester_leave";

		public function Sylvester(_arg1:String, _arg2:MovieClip){
			var _local3:SylvesterBaseState;
			super();
			m_charName = _arg1;
			m_gameMC = _arg2;
			_setupStateMCs();
			m_numConsecutiveSwipes = 0;
			m_isSwiping = false;
			m_isHit = false;
			_local3 = new SylvesterBaseState(this);
			m_fsm = new FiniteStateMachine(_arg1, _local3);
		}
		public function get charName():String{
			return (m_charName);
		}
		private function _setupStateMCs():void{
			mc_idle = _getSwfMovieClip("Sylvester_Idle");
			mc_comeIn = _getSwfMovieClip("Sylvester_ComeIn");
			mc_leave = _getSwfMovieClip("Sylvester_Leave");
			mc_hit = _getSwfMovieClip("Sylvester_Hit");
			mc_hitSwiping = _getSwfMovieClip("Sylvester_HitSwiping");
			mc_wait1 = _getSwfMovieClip("Sylvester_Wait1");
			mc_swipe1 = _getSwfMovieClip("Sylvester_Swipe1");
			mc_wait2 = _getSwfMovieClip("Sylvester_Wait2");
			mc_swipe2 = _getSwfMovieClip("Sylvester_Swipe2");
			mc_peek1 = _getSwfMovieClip("Sylvester_Peek1");
			mc_peek2 = _getSwfMovieClip("Sylvester_Peek2");
			mc_peek3 = _getSwfMovieClip("Sylvester_Peek3");
			mc_peek4 = _getSwfMovieClip("Sylvester_Peek4");
		}
		public function get attackMode():uint{
			return (m_attackMode);
		}
		public function getCurrentState():SylvesterBaseState{
			return ((m_fsm.currentState as SylvesterBaseState));
		}
		private function _changeState(_arg1:IFSMState, _arg2:Boolean=false):void{
			m_fsm.ChangeState(_arg1, _arg2);
		}
		public function get minComeInInterval():Number{
			return (m_minComeInInterval);
		}
		private function _exitCurrentState():void{
			this.getCurrentState().exit();
		}
		private function _onAtkIntervalDone(_arg1:TimerEvent):void{
			var _local2:Number;
			var _local3:SylvesterWaitForSwipeState;
			m_atkTimer.removeEventListener(TimerEvent.TIMER, _onAtkIntervalDone);
			m_atkTimer.stop();
			m_atkTimer = null;
			_local2 = Math.random();
			m_attackMode = ((_local2)<0.5) ? MODE1 : MODE2;
			m_currentWaitView = ((_local2)<0.5) ? mc_wait1 : mc_wait2;
			m_currentSwipeView = ((_local2)<0.5) ? mc_swipe1 : mc_swipe2;
			_local3 = new SylvesterWaitForSwipeState(this, m_currentWaitView);
			_changeState(_local3);
		}
		public function attack():void{
			var _local1:Number;
			if (!m_isHit){
				_local1 = (Math.floor((m_maxAtkInterval * Math.random())) + 1);
				m_atkTimer = new Timer(_local1, 1);
				m_atkTimer.addEventListener(TimerEvent.TIMER, _onAtkIntervalDone);
				m_atkTimer.start();
			};
		}
		public function comeIn():void{
			var _local1:Number;
			m_isSwiping = false;
			m_isHit = false;
			_local1 = (m_minComeInInterval + Math.floor((Math.random() * (m_maxComeInInterval - m_minComeInInterval))));
			m_comeInTimer = new Timer(_local1);
			m_comeInTimer.addEventListener(TimerEvent.TIMER, _onComeInIntervalDone);
			m_comeInTimer.start();
		}
		public function swipe():void{
			var _local1:SylvesterSwipeState;
			SoundManager.getInstance().playSound("Swipe_SFX");
			m_numConsecutiveSwipes++;
			_local1 = new SylvesterSwipeState(this, m_currentSwipeView);
			_changeState(_local1);
		}
		public function get side():uint{
			return (m_side);
		}
		public function set minComeInInterval(_arg1:Number):void{
			m_minComeInInterval = (_arg1 * 1000);
		}
		public function get waitInterval():Number{
			return (m_waitInterval);
		}
		public function peek():void{
			var _local1:uint;
			var _local2:MovieClip;
			var _local3:SylvesterLeaveState;
			_local1 = (Math.floor((Math.random() * 4)) + 1);
			switch (_local1){
				case 1:
					_local2 = mc_peek1;
					break;
				case 2:
					_local2 = mc_peek2;
					break;
				case 3:
					_local2 = mc_peek3;
					break;
				case 4:
					_local2 = mc_peek4;
					break;
			};
			_local3 = new SylvesterLeaveState(this, _local2);
			_changeState(_local3);
		}
		public function set maxComeInInterval(_arg1:Number):void{
			m_maxComeInInterval = (_arg1 * 1000);
		}
		public function comeInDone():void{
			this.dispatchEvent(new Event(COME_IN));
		}
		private function _getSwfMovieClip(_arg1:String):MovieClip{
			var _local2:Class;
			_local2 = (m_gameMC.loaderInfo.applicationDomain.getDefinition(_arg1) as Class);
			return ((new (_local2) as MovieClip));
		}
		public function get stateMachine():FiniteStateMachine{
			return (m_fsm);
		}
		public function get maxAtkInterval():Number{
			return (m_maxAtkInterval);
		}
		public function hit():void{
			var _local1:MovieClip;
			var _local2:SylvesterHitState;
			m_isHit = true;
			if (m_atkTimer != null){
				m_atkTimer.removeEventListener(TimerEvent.TIMER, _onAtkIntervalDone);
				m_atkTimer.stop();
				m_atkTimer = null;
			};
			this.dispatchEvent(new Event(LEAVE));
			_local1 = (m_isSwiping) ? mc_hitSwiping : mc_hit;
			if (m_isSwiping){
				SoundManager.getInstance().playSound("POW_Swiping_SFX");
			} else {
				SoundManager.getInstance().playSound("POW_Idle_SFX");
			};
			_local2 = new SylvesterHitState(this, _local1);
			_changeState(_local2);
		}
		public function get maxComeInInterval():Number{
			return (m_maxComeInInterval);
		}
		public function set waitInterval(_arg1:Number):void{
			m_waitInterval = (_arg1 * 1000);
		}
		public function leave():void{
			var _local1:SylvesterLeaveState;
			this.dispatchEvent(new Event(LEAVE));
			_local1 = new SylvesterLeaveState(this, mc_leave);
			_changeState(_local1);
		}
		public function inComa():void{
			var _local1:SylvesterComaState;
			_local1 = new SylvesterComaState(this);
			_changeState(_local1);
		}
		public function set comaInterval(_arg1:Number):void{
			m_comaInterval = (_arg1 * 1000);
		}
		public function set isSwiping(_arg1:Boolean):void{
			m_isSwiping = _arg1;
		}
		public function idle(_arg1:Boolean):void{
			var _local2:SylvesterIdleState;
			_local2 = new SylvesterIdleState(this, mc_idle, _arg1);
			_changeState(_local2);
		}
		public function get numConsecutiveSwipes():uint{
			return (m_numConsecutiveSwipes);
		}
		public function get comaInterval():Number{
			return (m_comaInterval);
		}
		public function get isSwiping():Boolean{
			return (m_isSwiping);
		}
		private function _onComeInIntervalDone(_arg1:TimerEvent):void{
			var _local2:Number;
			var _local3:SylvesterComeInState;
			m_comeInTimer.removeEventListener(TimerEvent.TIMER, _onComeInIntervalDone);
			_local2 = Math.random();
			m_side = ((_local2)<0.5) ? LEFT : RIGHT;
			_local3 = new SylvesterComeInState(this, mc_comeIn);
			_changeState(_local3);
		}
		public function set maxAtkInterval(_arg1:Number):void{
			m_maxAtkInterval = (_arg1 * 1000);
		}
		public function destroy():void{
			if (m_comeInTimer != null){
				m_comeInTimer.stop();
				if (m_comeInTimer.hasEventListener(TimerEvent.TIMER)){
					m_comeInTimer.removeEventListener(TimerEvent.TIMER, _onComeInIntervalDone);
				};
				m_comeInTimer = null;
			};
			if (m_atkTimer != null){
				m_atkTimer.stop();
				if (m_atkTimer.hasEventListener(TimerEvent.TIMER)){
					m_atkTimer.removeEventListener(TimerEvent.TIMER, _onAtkIntervalDone);
				};
				m_atkTimer = null;
			};
			_exitCurrentState();
			m_fsm.destroy();
			m_currentWaitView = null;
			m_currentSwipeView = null;
			mc_idle = null;
			mc_comeIn = null;
			mc_leave = null;
			mc_hit = null;
			mc_hitSwiping = null;
			mc_wait1 = null;
			mc_swipe1 = null;
			mc_wait2 = null;
			mc_swipe2 = null;
			mc_peek1 = null;
			mc_peek2 = null;
			mc_peek3 = null;
			mc_peek4 = null;
			m_gameMC = null;
		}

	}
}//package warnerbros.tweety.data 
Section 53
//TweetyBird (warnerbros.tweety.data.TweetyBird)
package warnerbros.tweety.data {
	import warnerbros.tweety.*;
	import flash.events.*;
	import flash.display.*;
	import ndi.ai.*;
	import qbert.data.*;
	import warnerbros.tweety.states.*;

	public class TweetyBird extends Character {

		private var mc_reappear:MovieClip;
		private var m_gameMC:MovieClip;
		private var m_isOnEdge:Boolean;
		private var mc_jumpSide:MovieClip;
		private var mc_jumpUp:MovieClip;
		private var m_isFacingBack:Boolean;
		private var m_isDying:Boolean;
		private var m_isFacingLeft:Boolean;
		private var mc_fallEdge:MovieClip;
		private var mc_idle:MovieClip;
		private var mc_hit:MovieClip;
		private var mc_fallHole:MovieClip;
		private var mc_idleBack:MovieClip;
		private var m_livesLeft:uint;
		private var mc_jumpDown:MovieClip;

		public static const CLEAN_TILE:String = "tweetybird_clean_tile";
		public static const NUMBER_OF_LIVES:uint = 3;
		public static const PICKUP_ITEM:String = "tweetybird_pickup_item";
		public static const DEATH:String = "tweetybird_death";
		public static const STATE_CHANGED:String = "tweetybird_state_changed";

		public function TweetyBird(_arg1:String, _arg2:HexTile, _arg3:MovieClip, _arg4:uint){
			var _local5:BirdIdleState;
			super(_arg1, _arg2);
			m_gameMC = _arg3;
			_setupStateMCs();
			m_livesLeft = _arg4;
			m_isDying = false;
			m_isOnEdge = false;
			m_isFacingBack = false;
			m_isFacingLeft = true;
			_local5 = new BirdIdleState(this, m_tile.posX, m_tile.posY, mc_idle);
			m_fsm = new FiniteStateMachine(_arg1, _local5);
		}
		private function _changeState(_arg1:IFSMState, _arg2:Boolean=false):void{
			m_fsm.ChangeState(_arg1, _arg2);
		}
		public function destroy():void{
			_exitCurrentState();
			m_fsm.destroy();
			mc_idle = null;
			mc_idleBack = null;
			mc_jumpUp = null;
			mc_jumpDown = null;
			mc_jumpSide = null;
			mc_fallHole = null;
			mc_hit = null;
			mc_fallEdge = null;
			mc_reappear = null;
		}
		public function getPickup():void{
			this.dispatchEvent(new Event(PICKUP_ITEM));
		}
		public function set isOnEdge(_arg1:Boolean):void{
			m_isOnEdge = _arg1;
		}
		public function getCurrentState():BirdBaseState{
			return ((m_fsm.currentState as BirdBaseState));
		}
		public function set livesLeft(_arg1:uint):void{
			m_livesLeft = _arg1;
		}
		public function set isFacingLeft(_arg1:Boolean):void{
			m_isFacingLeft = _arg1;
		}
		public function cleanTile():void{
			var _local1:Event;
			_local1 = new Event(CLEAN_TILE);
			this.dispatchEvent(_local1);
		}
		private function _setupStateMCs():void{
			mc_idle = _getSwfMovieClip("Bird_Idle");
			mc_idleBack = _getSwfMovieClip("Bird_IdleBack");
			mc_jumpUp = _getSwfMovieClip("Bird_JumpUp");
			mc_jumpDown = _getSwfMovieClip("Bird_JumpDown");
			mc_jumpSide = _getSwfMovieClip("Bird_JumpSide");
			mc_fallHole = _getSwfMovieClip("Bird_FallHole");
			mc_hit = _getSwfMovieClip("Bird_Hit");
			mc_fallEdge = _getSwfMovieClip("Bird_FallEdge");
			mc_reappear = _getSwfMovieClip("Bird_Reappear");
		}
		public function get isOnEdge():Boolean{
			return (m_isOnEdge);
		}
		public function reappear():void{
			var _local1:BirdReappearState;
			m_isFacingBack = false;
			m_isFacingLeft = true;
			_local1 = new BirdReappearState(this, m_tile.posX, m_tile.posY, mc_reappear);
			_changeState(_local1);
		}
		public function get isDying():Boolean{
			return (m_isDying);
		}
		public function die():void{
			var _local1:Event;
			_local1 = new Event(DEATH);
			this.dispatchEvent(_local1);
		}
		public function inDanger(_arg1:uint):void{
			var _local2:MovieClip;
			var _local3:BirdDangerState;
			m_livesLeft--;
			if (_arg1 == DangerType.HOLE){
				_local2 = mc_fallHole;
				SoundManager.getInstance().playSound("Tweety_Fall_SFX");
			} else {
				if (_arg1 == DangerType.SWIPE){
					_local2 = mc_hit;
				} else {
					if (_arg1 == DangerType.EDGE){
						m_isOnEdge = true;
						_local2 = mc_fallEdge;
						SoundManager.getInstance().playSound("Tweety_Fall_SFX");
					};
				};
			};
			_local3 = new BirdDangerState(this, m_tile.posX, m_tile.posY, _local2);
			_changeState(_local3);
		}
		private function _exitCurrentState():void{
			this.getCurrentState().exit();
		}
		public function get livesLeft():uint{
			return (m_livesLeft);
		}
		public function set isDying(_arg1:Boolean):void{
			m_isDying = _arg1;
		}
		public function set isFacingBack(_arg1:Boolean):void{
			m_isFacingBack = _arg1;
		}
		public function move(_arg1:String, _arg2:HexTile):void{
			var _local3:MovieClip;
			var _local4:BirdMoveState;
			switch (_arg1){
				case HexTile.POS_UP:
					_local3 = mc_jumpUp;
					m_isFacingBack = true;
					break;
				case HexTile.POS_DOWN:
					_local3 = mc_jumpDown;
					m_isFacingBack = false;
					break;
				case HexTile.POS_UPLEFT:
					_local3 = mc_jumpSide;
					m_isFacingBack = true;
					m_isFacingLeft = true;
					break;
				case HexTile.POS_DOWNLEFT:
					_local3 = mc_jumpSide;
					m_isFacingBack = false;
					m_isFacingLeft = true;
					break;
				case HexTile.POS_UPRIGHT:
					_local3 = mc_jumpSide;
					m_isFacingBack = true;
					m_isFacingLeft = false;
					break;
				case HexTile.POS_DOWNRIGHT:
					_local3 = mc_jumpSide;
					m_isFacingBack = false;
					m_isFacingLeft = false;
					break;
			};
			_local3.scaleX = (m_isFacingLeft) ? 1 : -1;
			_local4 = new BirdMoveState(this, m_tile.posX, m_tile.posY, _local3, _arg2);
			_changeState(_local4);
		}
		private function _getSwfMovieClip(_arg1:String):MovieClip{
			var _local2:Class;
			_local2 = (m_gameMC.loaderInfo.applicationDomain.getDefinition(_arg1) as Class);
			return ((new (_local2) as MovieClip));
		}
		public function idle():void{
			var _local1:MovieClip;
			var _local2:BirdIdleState;
			_local1 = (m_isFacingBack) ? mc_idleBack : mc_idle;
			_local1.scaleX = (m_isFacingLeft) ? 1 : -1;
			_local2 = new BirdIdleState(this, m_tile.posX, m_tile.posY, _local1);
			_changeState(_local2);
		}

	}
}//package warnerbros.tweety.data 
Section 54
//ButtonEvent (warnerbros.tweety.events.ButtonEvent)
package warnerbros.tweety.events {
	import flash.events.*;

	public class ButtonEvent extends Event {

		public static const OVER:String = "ButtonEvent_over";
		public static const CLICK:String = "ButtonEvent_click";
		public static const DOWN:String = "ButtonEvent_down";
		public static const OUT:String = "ButtonEvent_out";

		public function ButtonEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false){
			super(_arg1, _arg2, _arg3);
		}
	}
}//package warnerbros.tweety.events 
Section 55
//PickupEvent (warnerbros.tweety.events.PickupEvent)
package warnerbros.tweety.events {
	import flash.events.*;

	public class PickupEvent extends Event {

		private var m_hexTileId:uint;

		public function PickupEvent(_arg1:String, _arg2:uint, _arg3:Boolean=false, _arg4:Boolean=false){
			super(_arg1, _arg3, _arg4);
			m_hexTileId = _arg2;
		}
		public function get hexTileId():uint{
			return (m_hexTileId);
		}

	}
}//package warnerbros.tweety.events 
Section 56
//StartGameEvent (warnerbros.tweety.events.StartGameEvent)
package warnerbros.tweety.events {
	import flash.events.*;

	public class StartGameEvent extends Event {

		public var m_level:Number;
		public var m_score:Number;

		public function StartGameEvent(_arg1:String, _arg2:Number, _arg3:Boolean=false, _arg4:Boolean=false){
			m_level = _arg2;
			super(_arg1, _arg3, _arg4);
		}
	}
}//package warnerbros.tweety.events 
Section 57
//PointAnimation (warnerbros.tweety.gui.PointAnimation)
package warnerbros.tweety.gui {
	import flash.events.*;
	import flash.display.*;

	public class PointAnimation extends EventDispatcher {

		private var m_view:MovieClip;
		private var m_id:uint;

		public static const END:String = "pointanimation_end";

		public function PointAnimation(_arg1:MovieClip, _arg2:uint){
			m_view = _arg1;
			m_id = _arg2;
		}
		public function get id():uint{
			return (m_id);
		}
		public function destroy():void{
			if (m_view){
				if (m_view.hasEventListener(Event.ENTER_FRAME)){
					m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				};
				m_view = null;
			};
		}
		public function rollup(_arg1:int):void{
			m_view.point_mc.point_field.text = ("+" + _arg1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			m_view.gotoAndPlay(2);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_view.visible = false;
				this.dispatchEvent(new Event(END));
			};
		}
		public function get view():MovieClip{
			return (m_view);
		}

	}
}//package warnerbros.tweety.gui 
Section 58
//SimpleButton (warnerbros.tweety.gui.SimpleButton)
package warnerbros.tweety.gui {
	import warnerbros.tweety.*;
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.events.*;

	public class SimpleButton extends EventDispatcher {

		private var m_pressedSound:String;
		private var m_enabled:Boolean;// = true
		private var m_view:MovieClip;

		public function SimpleButton(_arg1:MovieClip, _arg2:String="UI_Click_SFX"){
			m_enabled = true;
			super();
			m_view = _arg1;
			m_view.gotoAndStop("up");
			m_pressedSound = _arg2;
			m_view.addEventListener(MouseEvent.MOUSE_OVER, _onMouseOver);
			m_view.addEventListener(MouseEvent.MOUSE_OUT, _onMouseOut);
			m_view.addEventListener(MouseEvent.MOUSE_DOWN, _onMouseDown);
			m_view.addEventListener(MouseEvent.CLICK, _onClick);
			m_view.useHandCursor = true;
			m_view.buttonMode = true;
		}
		public function set enabled(_arg1:Boolean):void{
			m_enabled = _arg1;
			buttonEnabled = _arg1;
		}
		public function get enabled():Boolean{
			return (m_enabled);
		}
		private function _onMouseDown(_arg1:MouseEvent):void{
			m_view.gotoAndStop("down");
		}
		private function _onMouseOver(_arg1:MouseEvent):void{
			_doOnMouseOver();
		}
		private function _onMouseOut(_arg1:MouseEvent):void{
			m_view.gotoAndStop("up");
		}
		public function set buttonEnabled(_arg1:Boolean):void{
			if (_arg1){
				m_view.addEventListener(MouseEvent.MOUSE_OVER, _onMouseOver);
				m_view.addEventListener(MouseEvent.MOUSE_OUT, _onMouseOut);
				m_view.addEventListener(MouseEvent.MOUSE_DOWN, _onMouseDown);
				m_view.addEventListener(MouseEvent.CLICK, _onClick);
				if (m_view.hitTestPoint(m_view.stage.mouseX, m_view.stage.mouseY, true)){
					_doOnMouseOver();
				};
			} else {
				m_view.removeEventListener(MouseEvent.MOUSE_OVER, _onMouseOver);
				m_view.removeEventListener(MouseEvent.MOUSE_OUT, _onMouseOut);
				m_view.removeEventListener(MouseEvent.MOUSE_DOWN, _onMouseDown);
				m_view.removeEventListener(MouseEvent.CLICK, _onClick);
			};
			m_view.useHandCursor = _arg1;
			m_view.buttonMode = _arg1;
		}
		private function _onClick(_arg1:MouseEvent):void{
			var _local2:ButtonEvent;
			if (m_view == null){
				return;
			};
			if (m_pressedSound != null){
				SoundManager.getInstance().playSound(m_pressedSound);
			};
			m_view.gotoAndStop("up");
			_local2 = new ButtonEvent(ButtonEvent.CLICK);
			dispatchEvent(_local2);
		}
		private function _doOnMouseOver():void{
			m_view.gotoAndStop("over");
		}
		public function destroy():void{
			m_view.removeEventListener(MouseEvent.MOUSE_OVER, _onMouseOver);
			m_view.removeEventListener(MouseEvent.MOUSE_OUT, _onMouseOut);
			m_view.removeEventListener(MouseEvent.MOUSE_DOWN, _onMouseDown);
			m_view.removeEventListener(MouseEvent.CLICK, _onClick);
			m_view = null;
		}
		public function get view():MovieClip{
			return (m_view);
		}

	}
}//package warnerbros.tweety.gui 
Section 59
//BetweenLevelScreen (warnerbros.tweety.screens.BetweenLevelScreen)
package warnerbros.tweety.screens {
	import flash.events.*;
	import flash.display.*;
	import flash.text.*;

	public class BetweenLevelScreen extends EventDispatcher {

		private var m_view:MovieClip;

		public static const CONTINUE:String = "betweenlevelscreen_continue";

		public function BetweenLevelScreen(_arg1:MovieClip, _arg2:uint){
			var _local3:uint;
			super();
			m_view = _arg1;
			_local3 = (((_arg2 % 5))==0) ? 5 : (_arg2 % 5);
			m_view.mc_bg.gotoAndStop(_local3);
			TextField(m_view.mc_level.txt_numLevel).text = _fillZero(_arg2);
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _fillZero(_arg1:uint):String{
			var _local2:String;
			_local2 = _arg1.toString();
			while (_local2.length < 3) {
				_local2 = ("0" + _local2);
			};
			return (_local2);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				this.dispatchEvent(new Event(CONTINUE));
			};
		}
		public function get view():MovieClip{
			return (m_view);
		}

	}
}//package warnerbros.tweety.screens 
Section 60
//GameOverScreen (warnerbros.tweety.screens.GameOverScreen)
package warnerbros.tweety.screens {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.events.*;
	import warnerbros.tweety.gui.*;

	public class GameOverScreen extends EventDispatcher {

		private var m_playAgainButton:SimpleButton;
		private var m_interactive:Boolean;
		private var m_score:Number;
		private var m_view:MovieClip;

		public static const START_GAME:String = "gameoverscreen_start_game";

		public function GameOverScreen(_arg1:MovieClip, _arg2:Boolean, _arg3:Number){
			m_view = _arg1;
			m_score = _arg3;
			if (_arg2){
				m_view.gotoAndStop(1);
			} else {
				m_view.gotoAndStop(2);
			};
			m_interactive = true;
			m_view.addEventListener(Event.ENTER_FRAME, _onInit);
		}
		private function _onPlayAgainClicked(_arg1:ButtonEvent):void{
			var _local2:StartGameEvent;
			_local2 = new StartGameEvent(START_GAME, 0);
			dispatchEvent(_local2);
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function setInteractive(_arg1:Boolean):void{
			m_playAgainButton.enabled = _arg1;
		}
		private function _onInit(_arg1:Event):void{
			m_view.removeEventListener(Event.ENTER_FRAME, _onInit);
			m_view.score_tf.text = m_score.toString();
			m_playAgainButton = new SimpleButton(m_view.playAgain_btn);
			m_playAgainButton.addEventListener(ButtonEvent.CLICK, _onPlayAgainClicked);
			m_playAgainButton.enabled = m_interactive;
		}
		public function destroy():void{
			m_playAgainButton.removeEventListener(ButtonEvent.CLICK, _onPlayAgainClicked);
			m_playAgainButton.destroy();
			m_playAgainButton = null;
		}

	}
}//package warnerbros.tweety.screens 
Section 61
//InstructionsScreen (warnerbros.tweety.screens.InstructionsScreen)
package warnerbros.tweety.screens {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.events.*;
	import fl.transitions.*;
	import warnerbros.tweety.gui.*;

	public class InstructionsScreen extends EventDispatcher {

		private var m_tween:Tween;
		private var m_startGameBtn:SimpleButton;
		private var m_forwardArrowBtn:SimpleButton;
		private var m_pageIndex:int;
		private var m_backArrowBtn:SimpleButton;
		private var m_view:MovieClip;

		public static const START_GAME:String = "InstructionsScreen_startGame";

		public function InstructionsScreen(_arg1:MovieClip){
			m_view = _arg1;
			m_backArrowBtn = new SimpleButton(m_view.back_btn);
			m_backArrowBtn.addEventListener(ButtonEvent.CLICK, _onBackArrowClick);
			m_forwardArrowBtn = new SimpleButton(m_view.forward_btn);
			m_forwardArrowBtn.addEventListener(ButtonEvent.CLICK, _onForwardArrowClick);
			m_startGameBtn = new SimpleButton(m_view.play_btn);
			m_startGameBtn.addEventListener(ButtonEvent.CLICK, _onStartGameClick);
			m_pageIndex = 1;
			m_view.gotoAndStop(m_pageIndex);
			_adjustArrows();
		}
		private function _previousPage():void{
			if (m_tween){
				return;
			};
			if (m_pageIndex <= 1){
				return;
			};
			m_pageIndex--;
			m_tween = new Tween(m_view.page_mc, "alpha", null, 1, 0, 7);
			m_tween.addEventListener(TweenEvent.MOTION_FINISH, _onPageFadeOutDone);
		}
		private function _nextPage():void{
			if (m_tween){
				return;
			};
			if (m_pageIndex >= m_view.totalFrames){
				return;
			};
			m_pageIndex++;
			m_tween = new Tween(m_view.page_mc, "alpha", null, 1, 0, 7);
			m_tween.addEventListener(TweenEvent.MOTION_FINISH, _onPageFadeOutDone);
		}
		private function _onStartGameClick(_arg1:ButtonEvent):void{
			var _local2:Event;
			m_backArrowBtn.removeEventListener(ButtonEvent.CLICK, _onBackArrowClick);
			m_forwardArrowBtn.removeEventListener(ButtonEvent.CLICK, _onForwardArrowClick);
			m_startGameBtn.removeEventListener(ButtonEvent.CLICK, _onStartGameClick);
			if (m_tween){
				m_tween.removeEventListener(TweenEvent.MOTION_FINISH, _onPageFadeOutDone);
			};
			m_backArrowBtn.destroy();
			m_forwardArrowBtn.destroy();
			m_startGameBtn.destroy();
			_local2 = new Event(START_GAME);
			dispatchEvent(_local2);
		}
		private function _onForwardArrowClick(_arg1:ButtonEvent):void{
			_nextPage();
		}
		private function _adjustArrows():void{
			m_view.forward_btn.visible = ((m_pageIndex)>=m_view.totalFrames) ? false : true;
			m_view.back_btn.visible = ((m_pageIndex)<=1) ? false : true;
		}
		private function _onBackArrowClick(_arg1:ButtonEvent):void{
			_previousPage();
		}
		public function get view():MovieClip{
			return (m_view);
		}
		private function _onPageFadeOutDone(_arg1:Event):void{
			m_tween.removeEventListener(TweenEvent.MOTION_FINISH, _onPageFadeOutDone);
			m_tween = null;
			m_view.gotoAndStop(m_pageIndex);
			_adjustArrows();
		}

	}
}//package warnerbros.tweety.screens 
Section 62
//SplashScreen (warnerbros.tweety.screens.SplashScreen)
package warnerbros.tweety.screens {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.events.*;
	import warnerbros.tweety.gui.*;

	public class SplashScreen extends EventDispatcher {

		private var m_instructionsButton:SimpleButton;
		private var m_playButton:SimpleButton;
		private var m_view:MovieClip;

		public static const SHOW_INSTRUCTIONS:String = "splashscreen_show_instructions";
		public static const START_GAME:String = "splashscreen_start_game";

		public function SplashScreen(_arg1:MovieClip){
			m_view = _arg1;
			m_playButton = new SimpleButton(m_view.play_btn);
			m_playButton.addEventListener(ButtonEvent.CLICK, _onPlayClick);
			m_instructionsButton = new SimpleButton(m_view.instructions_btn);
			m_instructionsButton.addEventListener(ButtonEvent.CLICK, _onInstructionsClick);
		}
		private function _onInstructionsClick(_arg1:ButtonEvent):void{
			var _local2:Event;
			_local2 = new Event(SHOW_INSTRUCTIONS);
			dispatchEvent(_local2);
		}
		private function _onPlayClick(_arg1:ButtonEvent):void{
			var _local2:StartGameEvent;
			_local2 = new StartGameEvent(START_GAME, 0);
			dispatchEvent(_local2);
		}
		public function setInteractive(_arg1:Boolean):void{
			m_playButton.enabled = _arg1;
			m_instructionsButton.enabled = _arg1;
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function destroy():void{
			m_playButton.removeEventListener(ButtonEvent.CLICK, _onPlayClick);
			m_playButton.destroy();
			m_playButton = null;
			m_instructionsButton.removeEventListener(ButtonEvent.CLICK, _onInstructionsClick);
			m_instructionsButton.destroy();
			m_instructionsButton = null;
		}

	}
}//package warnerbros.tweety.screens 
Section 63
//BirdBaseState (warnerbros.tweety.states.BirdBaseState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import ndi.ai.*;
	import warnerbros.tweety.data.*;

	public class BirdBaseState implements IFSMState {

		protected var m_owner:TweetyBird;
		protected var m_view:MovieClip;
		protected var m_positionX:Number;
		protected var m_positionY:Number;

		public function BirdBaseState(_arg1:TweetyBird, _arg2:Number, _arg3:Number){
			m_owner = _arg1;
			m_positionX = _arg2;
			m_positionY = _arg3;
		}
		public function set paused(_arg1:Boolean):void{
			if (_arg1){
				m_view.stop();
			} else {
				m_view.play();
			};
		}
		public function exit():void{
			m_view.visible = false;
		}
		public function update(_arg1:Number):void{
		}
		public function toString():String{
			return ("BirdBaseState");
		}
		public function destroy():void{
			m_view = null;
			m_owner = null;
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function enter():void{
			m_view.mouseEnabled = false;
			m_view.mouseChildren = false;
			m_view.x = m_positionX;
			m_view.y = (m_positionY - 10);
			m_view.play();
			m_view.visible = true;
			m_owner.dispatchEvent(new Event(TweetyBird.STATE_CHANGED));
		}

	}
}//package warnerbros.tweety.states 
Section 64
//BirdDangerState (warnerbros.tweety.states.BirdDangerState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class BirdDangerState extends BirdBaseState {

		public function BirdDangerState(_arg1:TweetyBird, _arg2:Number, _arg3:Number, _arg4:MovieClip){
			super(_arg1, _arg2, _arg3);
			m_view = _arg4;
		}
		override public function exit():void{
			super.exit();
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function toString():String{
			return ("BirdDangerState");
		}
		override public function enter():void{
			super.enter();
			m_owner.tile.occupied = false;
			m_owner.isDying = true;
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_owner.die();
			};
		}

	}
}//package warnerbros.tweety.states 
Section 65
//BirdIdleState (warnerbros.tweety.states.BirdIdleState)
package warnerbros.tweety.states {
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class BirdIdleState extends BirdBaseState {

		public function BirdIdleState(_arg1:TweetyBird, _arg2:Number, _arg3:Number, _arg4:MovieClip){
			super(_arg1, _arg2, _arg3);
			m_view = _arg4;
		}
		override public function toString():String{
			return ("BirdIdleState");
		}
		override public function enter():void{
			super.enter();
			m_owner.tile.occupied = true;
		}

	}
}//package warnerbros.tweety.states 
Section 66
//BirdMoveState (warnerbros.tweety.states.BirdMoveState)
package warnerbros.tweety.states {
	import flash.display.*;
	import qbert.data.*;
	import warnerbros.tweety.data.*;
	import fl.transitions.*;
	import fl.transitions.easing.*;

	public class BirdMoveState extends BirdBaseState {

		private var m_tweenX:Tween;
		private var m_tweenY:Tween;
		private var m_targetTile:HexTile;

		public function BirdMoveState(_arg1:TweetyBird, _arg2:Number, _arg3:Number, _arg4:MovieClip, _arg5:HexTile){
			super(_arg1, _arg2, _arg3);
			m_view = _arg4;
			m_targetTile = _arg5;
		}
		private function _onMoveDone(_arg1:TweenEvent):void{
			var _local2:Boolean;
			var _local3:Boolean;
			m_tweenX.removeEventListener(TweenEvent.MOTION_FINISH, _onMoveDone);
			_local2 = !((m_owner.tile.relativeAdjPos.indexOf("up") == -1));
			_local3 = (m_owner.tile.relativeAdjPos.indexOf("right") == -1);
			m_owner.tile = m_targetTile;
			m_owner.tile.occupied = true;
			if (m_owner.tile.hasPickUp){
				m_owner.getPickup();
			};
			if (m_owner.tile.isDangerous){
				m_owner.inDanger(m_owner.tile.dangerType);
			} else {
				m_owner.idle();
				m_owner.cleanTile();
			};
		}
		override public function enter():void{
			super.enter();
			m_owner.tile.occupied = false;
			m_owner.isMoving = true;
			m_tweenX = new Tween(m_view, "x", None.easeNone, m_view.x, m_targetTile.posX, m_view.totalFrames, false);
			m_tweenY = new Tween(m_view, "y", None.easeNone, m_view.y, (m_targetTile.posY - 10), m_view.totalFrames, false);
			m_view.gotoAndPlay(1);
			m_tweenX.addEventListener(TweenEvent.MOTION_FINISH, _onMoveDone);
		}
		override public function exit():void{
			super.exit();
			m_owner.isMoving = false;
			if (m_tweenX){
				if (m_tweenX.hasEventListener(TweenEvent.MOTION_FINISH)){
					m_tweenX.removeEventListener(TweenEvent.MOTION_FINISH, _onMoveDone);
				};
				m_tweenX = null;
				m_tweenY = null;
			};
		}
		override public function toString():String{
			return ("BirdMoveState");
		}

	}
}//package warnerbros.tweety.states 
Section 67
//BirdReappearState (warnerbros.tweety.states.BirdReappearState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class BirdReappearState extends BirdBaseState {

		public function BirdReappearState(_arg1:TweetyBird, _arg2:Number, _arg3:Number, _arg4:MovieClip){
			super(_arg1, _arg2, _arg3);
			m_view = _arg4;
		}
		override public function exit():void{
			super.exit();
			m_owner.isDying = false;
			m_owner.isOnEdge = false;
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function toString():String{
			return ("BirdReappearState");
		}
		override public function enter():void{
			super.enter();
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_owner.idle();
			};
		}

	}
}//package warnerbros.tweety.states 
Section 68
//SylvesterBaseState (warnerbros.tweety.states.SylvesterBaseState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import ndi.ai.*;
	import warnerbros.tweety.data.*;

	public class SylvesterBaseState implements IFSMState {

		protected var m_owner:Sylvester;
		protected var m_view:MovieClip;

		public function SylvesterBaseState(_arg1:Sylvester){
			m_owner = _arg1;
		}
		public function update(_arg1:Number):void{
		}
		public function toString():String{
			return ("SylvesterBaseState");
		}
		public function get view():MovieClip{
			return (m_view);
		}
		public function enter():void{
			if (m_view != null){
				m_view.mouseEnabled = false;
				m_view.mouseChildren = false;
				if (m_owner.side == Sylvester.RIGHT){
					m_view.x = 391.8;
					m_view.scaleX = 1;
				} else {
					m_view.x = 157.2;
					m_view.scaleX = -1;
				};
				m_view.y = 108.9;
				m_view.visible = true;
				m_owner.dispatchEvent(new Event(Sylvester.STATE_CHANGED));
			};
		}
		public function destroy():void{
			m_view = null;
			m_owner = null;
		}
		public function set paused(_arg1:Boolean):void{
			if (_arg1){
				m_view.stop();
			} else {
				m_view.play();
			};
		}
		public function exit():void{
			if (m_view != null){
				m_view.visible = false;
			};
		}

	}
}//package warnerbros.tweety.states 
Section 69
//SylvesterComaState (warnerbros.tweety.states.SylvesterComaState)
package warnerbros.tweety.states {
	import flash.events.*;
	import warnerbros.tweety.data.*;
	import flash.utils.*;

	public class SylvesterComaState extends SylvesterBaseState {

		private var m_timer:Timer;

		public function SylvesterComaState(_arg1:Sylvester){
			super(_arg1);
		}
		override public function toString():String{
			return ("SylvesterComaState");
		}
		override public function exit():void{
			super.exit();
			if (m_timer){
				m_timer.stop();
				if (m_timer.hasEventListener(TimerEvent.TIMER)){
					m_timer.removeEventListener(TimerEvent.TIMER, _onTimer);
				};
				m_timer = null;
			};
		}
		private function _onTimer(_arg1:TimerEvent):void{
			m_timer.removeEventListener(TimerEvent.TIMER, _onTimer);
			m_timer.stop();
			m_timer = null;
			m_owner.comeIn();
		}
		override public function enter():void{
			super.enter();
			m_timer = new Timer(m_owner.comaInterval);
			m_timer.addEventListener(TimerEvent.TIMER, _onTimer);
			m_timer.start();
		}

	}
}//package warnerbros.tweety.states 
Section 70
//SylvesterComeInState (warnerbros.tweety.states.SylvesterComeInState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class SylvesterComeInState extends SylvesterBaseState {

		public function SylvesterComeInState(_arg1:Sylvester, _arg2:MovieClip){
			super(_arg1);
			m_view = _arg2;
		}
		override public function toString():String{
			return ("SylvesterComeInState");
		}
		override public function exit():void{
			super.exit();
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function enter():void{
			super.enter();
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_owner.comeInDone();
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_owner.idle(true);
			};
		}

	}
}//package warnerbros.tweety.states 
Section 71
//SylvesterHitState (warnerbros.tweety.states.SylvesterHitState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class SylvesterHitState extends SylvesterBaseState {

		public function SylvesterHitState(_arg1:Sylvester, _arg2:MovieClip){
			super(_arg1);
			m_view = _arg2;
		}
		override public function toString():String{
			return ("SylvesterHitState");
		}
		override public function exit():void{
			super.exit();
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function enter():void{
			super.enter();
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_owner.inComa();
			};
		}

	}
}//package warnerbros.tweety.states 
Section 72
//SylvesterIdleState (warnerbros.tweety.states.SylvesterIdleState)
package warnerbros.tweety.states {
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class SylvesterIdleState extends SylvesterBaseState {

		private var m_isFirstVisit:Boolean;

		public function SylvesterIdleState(_arg1:Sylvester, _arg2:MovieClip, _arg3:Boolean){
			super(_arg1);
			m_view = _arg2;
			m_isFirstVisit = _arg3;
		}
		override public function toString():String{
			return ("SylvesterIdleState");
		}
		override public function enter():void{
			var _local1:Number;
			super.enter();
			if (m_isFirstVisit){
				m_owner.attack();
			} else {
				if (m_owner.numConsecutiveSwipes < 3){
					_local1 = Math.random();
					if (_local1 < 0.5){
						m_owner.attack();
					} else {
						m_owner.leave();
					};
				} else {
					m_owner.leave();
				};
			};
		}

	}
}//package warnerbros.tweety.states 
Section 73
//SylvesterLeaveState (warnerbros.tweety.states.SylvesterLeaveState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class SylvesterLeaveState extends SylvesterBaseState {

		public function SylvesterLeaveState(_arg1:Sylvester, _arg2:MovieClip){
			super(_arg1);
			m_view = _arg2;
		}
		override public function exit():void{
			super.exit();
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCDone);
			};
		}
		private function _onWatchMCDone(_arg1:Event):void{
			var _local2:Number;
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCDone);
				_local2 = Math.random();
				if (_local2 < 0.3){
					m_owner.peek();
				} else {
					m_owner.comeIn();
				};
			};
		}
		override public function enter():void{
			super.enter();
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCDone);
		}

	}
}//package warnerbros.tweety.states 
Section 74
//SylvesterSwipeState (warnerbros.tweety.states.SylvesterSwipeState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;

	public class SylvesterSwipeState extends SylvesterBaseState {

		public function SylvesterSwipeState(_arg1:Sylvester, _arg2:MovieClip){
			super(_arg1);
			m_view = _arg2;
		}
		override public function toString():String{
			return ("SylvesterSwipeState");
		}
		override public function exit():void{
			super.exit();
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function enter():void{
			super.enter();
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			if (m_view.currentFrame >= 5){
				m_owner.dispatchEvent(new Event(Sylvester.SWIPED));
			};
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				m_owner.idle(false);
			};
		}

	}
}//package warnerbros.tweety.states 
Section 75
//SylvesterWaitForSwipeState (warnerbros.tweety.states.SylvesterWaitForSwipeState)
package warnerbros.tweety.states {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;
	import flash.utils.*;

	public class SylvesterWaitForSwipeState extends SylvesterBaseState {

		private var m_timer:Timer;

		public function SylvesterWaitForSwipeState(_arg1:Sylvester, _arg2:MovieClip){
			super(_arg1);
			m_view = _arg2;
		}
		private function _onWaitDone(_arg1:TimerEvent):void{
			m_timer.removeEventListener(TimerEvent.TIMER, _onWaitDone);
			m_timer.stop();
			m_timer = null;
			m_owner.swipe();
		}
		override public function toString():String{
			return ("SylvesterWaitForSwipeState");
		}
		override public function exit():void{
			super.exit();
			if (m_timer){
				m_timer.stop();
				if (m_timer.hasEventListener(TimerEvent.TIMER)){
					m_timer.removeEventListener(TimerEvent.TIMER, _onWaitDone);
				};
				m_timer = null;
			};
			if (m_view.hasEventListener(Event.ENTER_FRAME)){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			};
		}
		override public function enter():void{
			super.enter();
			m_owner.isSwiping = true;
			m_view.gotoAndPlay(1);
			m_view.addEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
			m_owner.dispatchEvent(new Event(Sylvester.SWIPE_WARNING));
		}
		private function _onWatchMCFinished(_arg1:Event):void{
			var _local2:Number;
			if (m_view.currentFrame == m_view.totalFrames){
				m_view.removeEventListener(Event.ENTER_FRAME, _onWatchMCFinished);
				_local2 = m_owner.waitInterval;
				m_timer = new Timer(_local2, 1);
				m_timer.addEventListener(TimerEvent.TIMER, _onWaitDone);
				m_timer.start();
			};
		}

	}
}//package warnerbros.tweety.states 
Section 76
//GameManager (warnerbros.tweety.GameManager)
package warnerbros.tweety {
	import flash.events.*;
	import flash.display.*;
	import qbert.data.*;
	import warnerbros.tweety.data.*;
	import qbert.events.*;
	import warnerbros.tweety.events.*;
	import flash.utils.*;
	import peach.config.*;
	import qbert.manager.*;
	import warnerbros.tweety.gui.*;

	public class GameManager extends EventDispatcher {

		private var m_dangerHT:HexTile;
		private var m_completedTiles:Array;
		private var m_dangerTimer:Timer;
		private var m_isMuted:Boolean;
		private var m_level:uint;
		private var m_enemy:Sylvester;
		private var m_holeGenProbability:Number;
		private var m_view:MovieClip;
		private var m_pickupManager:PickupManager;
		private var m_gameId:String;
		private var m_holeGenTimer:Timer;
		private var m_score:Number;
		private var m_holeTiles:Dictionary;
		private var m_character:TweetyBird;
		private var m_tileManager:TileManager;
		private var m_startTile:HexTile;
		private var m_pointAnimations:Dictionary;
		private var m_screenHolders:MovieClip;

		public static const BONUS_POINT1:uint = 1000;
		public static const BONUS_POINT3:uint = 2000;
		public static const BONUS_POINT2:uint = 1250;
		public static const WON_POINT:uint = 1000;
		public static const CLEANTILE_POINT:uint = 50;
		public static const LOST_GAME:String = "gamemanager_lost_game";
		public static const POW_POINT:uint = 200;
		public static const NEXT_LEVEL:String = "gamemanager_next_level";
		public static const WON_GAME:String = "gamemanager_won_game";
		public static const DANGER_DELAY_INTERVAL:uint = 200;
		public static const START_TILE_INDEX:uint = 46;

		public function GameManager(_arg1:MovieClip, _arg2:MovieClip, _arg3:String, _arg4:uint, _arg5:uint=0, _arg6:uint=3){
			var _local7:GameSettings;
			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:uint;
			var _local18:uint;
			super();
			m_view = _arg1;
			m_screenHolders = _arg2;
			m_gameId = _arg3;
			m_level = _arg4;
			m_score = _arg5;
			_local7 = GameSettings.getInstance(_arg3);
			m_tileManager = new TileManager(m_view.mc_hitzone, m_view.mc_tiles, 11, 8, true);
			m_tileManager.addEventListener(TileManager.TILE_HOVERED, _onTileHovered);
			m_tileManager.addEventListener(TileEvent.EDGE_DETECTED, _onEdgeTileDetected);
			m_tileManager.init();
			m_completedTiles = new Array();
			m_holeTiles = new Dictionary();
			m_pointAnimations = new Dictionary();
			switch (m_level){
				case 1:
					_local8 = 6;
					_local9 = 0.3;
					_local10 = 7;
					_local11 = 0.25;
					_local12 = 4;
					_local13 = 7;
					_local14 = 5;
					_local15 = 2;
					_local16 = 4;
					break;
				case 2:
					_local8 = 8;
					_local9 = 0.3;
					_local10 = 5;
					_local11 = 0.3;
					_local12 = 3;
					_local13 = 6;
					_local14 = 4;
					_local15 = 2;
					_local16 = 4;
					break;
				case 3:
					_local8 = 10;
					_local9 = 0.3;
					_local10 = 4;
					_local11 = 0.35;
					_local12 = 3;
					_local13 = 5;
					_local14 = 3;
					_local15 = 1.5;
					_local16 = 3;
					break;
				case 4:
					_local8 = 12;
					_local9 = 0.3;
					_local10 = 4;
					_local11 = 0.35;
					_local12 = 2;
					_local13 = 5;
					_local14 = 2;
					_local15 = 1.5;
					_local16 = 3;
					break;
				default:
					_local8 = 14;
					_local9 = 0.3;
					_local10 = 3;
					_local11 = 0.35;
					_local12 = 2;
					_local13 = 4;
					_local14 = 1.5;
					_local15 = 1;
					_local16 = 2;
					break;
			};
			m_pickupManager = new PickupManager(m_screenHolders, _local8);
			m_pickupManager.hammerAppProbability = _local9;
			m_pickupManager.addEventListener(PickupManager.GENERATE, _onPickupGenerated);
			m_pickupManager.addEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
			_local17 = START_TILE_INDEX;
			m_startTile = m_tileManager.getTile(_local17);
			m_character = new TweetyBird("TweetyBird", m_startTile, m_screenHolders, _arg6);
			m_character.addEventListener(TweetyBird.STATE_CHANGED, _onTweetyStateChanged);
			m_character.addEventListener(TweetyBird.PICKUP_ITEM, _onTweetyPickupItem);
			m_character.addEventListener(TweetyBird.CLEAN_TILE, _onTweetyCleanTile);
			m_character.addEventListener(TweetyBird.DEATH, _onTweetyDeath);
			m_character.idle();
			_setNumLevelText();
			_setScoreText();
			_setNumLivesText();
			m_view.sound_btn.addEventListener(MouseEvent.CLICK, _onSoundBtnClicked);
			_local18 = (((m_level % 5))==0) ? 5 : (m_level % 5);
			m_view.mc_bg.gotoAndStop(_local18);
			m_enemy = new Sylvester("Sylvester", m_screenHolders);
			m_enemy.minComeInInterval = _local12;
			m_enemy.maxComeInInterval = _local13;
			m_enemy.maxAtkInterval = _local14;
			m_enemy.waitInterval = _local15;
			m_enemy.comaInterval = _local16;
			m_enemy.addEventListener(Sylvester.STATE_CHANGED, _onSylvesterStateChanged);
			m_enemy.addEventListener(Sylvester.SWIPE_WARNING, _onSylvesterWarning);
			m_enemy.addEventListener(Sylvester.SWIPED, _onSylvesterSwiped);
			m_enemy.addEventListener(Sylvester.COME_IN, _onSylvesterComeIn);
			m_enemy.addEventListener(Sylvester.LEAVE, _onSylvesterLeft);
			m_enemy.comeIn();
			m_holeGenProbability = _local11;
			m_holeGenTimer = new Timer((_local10 * 1000));
			m_holeGenTimer.addEventListener(TimerEvent.TIMER, _onHoleGenTimer);
			m_holeGenTimer.start();
		}
		private function _setScoreText():void{
			m_view.txt_score.text = m_score.toString();
		}
		public function get level():Number{
			return (m_level);
		}
		private function _checkGameWon():void{
			var _local1:SoundManager;
			if (m_tileManager.numTiles == m_completedTiles.length){
				_scorePoints(WON_POINT);
				_local1 = SoundManager.getInstance();
				_local1.stopAllSounds();
				_local1.stopLoop("Music_Main");
				_local1.playSound("Win_SFX");
				this.dispatchEvent(new Event(NEXT_LEVEL));
			};
		}
		public function get score():Number{
			return (m_score);
		}
		private function _onSylvesterLeft(_arg1:Event):void{
			var _local2:HexTile;
			_local2 = m_tileManager.getTile(m_pickupManager.powLocation);
			if (((_local2.hasPickUp) && ((_local2.pickUpType == PickupType.POW)))){
				m_pickupManager.removePow();
			};
		}
		private function _onPointAnimationDone(_arg1:Event):void{
			var _local2:PointAnimation;
			_local2 = (_arg1.target as PointAnimation);
			_local2.removeEventListener(PointAnimation.END, _onPointAnimationDone);
			m_view.mc_pointLayer.removeChild(_local2.view);
			delete m_pointAnimations[_local2.id];
			_local2.destroy();
			_local2 = null;
		}
		private function _onPickupGenerated(_arg1:Event):void{
			var _local2:HexTile;
			var _local3:Pickup;
			var _local4:MovieClip;
			_local2 = m_tileManager.getEmptyTile();
			if (_local2 != null){
				_local3 = m_pickupManager.getNewPickup();
				m_pickupManager.insertItem(_local2.id, _local3);
				_local4 = _local3.view;
				m_view.mc_pickupLayer.addChild(_local4);
				_local4.x = _local2.posX;
				_local4.y = _local2.posY;
				_local2.pickUpType = _local3.type;
				_local2.hasPickUp = true;
			};
		}
		private function _addHoleTile(_arg1:HexTile):void{
			SoundManager.getInstance().playSound("Hole_crash_SFX");
			m_holeTiles[_arg1.id] = _arg1;
			_arg1.dangerType = DangerType.HOLE;
			_arg1.isDangerous = true;
			_arg1.state = HexTileState.HOLE;
		}
		private function _onTweetyPickupItem(_arg1:Event):void{
			var _local2:HexTile;
			var _local3:Pickup;
			var _local4:Number;
			_local2 = m_character.tile;
			_local2.hasPickUp = false;
			_local3 = m_pickupManager.getItem(_local2.id);
			m_pickupManager.removeItem(_local2.id);
			m_view.mc_pickupLayer.removeChild(_local3.view);
			m_character.idle();
			switch (_local3.type){
				case PickupType.BONUS1:
					SoundManager.getInstance().playSound("Bonus_SFX");
					_local4 = BONUS_POINT1;
					_scorePoints(_local4);
					_createPointAnimation(_local2, _local4);
					break;
				case PickupType.BONUS2:
					SoundManager.getInstance().playSound("Bonus_SFX");
					_local4 = BONUS_POINT2;
					_scorePoints(_local4);
					_createPointAnimation(_local2, _local4);
					break;
				case PickupType.BONUS3:
					SoundManager.getInstance().playSound("Bonus_SFX");
					_local4 = BONUS_POINT3;
					_scorePoints(_local4);
					_createPointAnimation(_local2, _local4);
					break;
				case PickupType.HAMMER_NAIL:
					SoundManager.getInstance().playSound("HammerNails_SFX");
					_scorePoints(POW_POINT);
					_hammerNailHoles();
					m_pickupManager.hammerItemAvailable();
					break;
				case PickupType.POW:
					_powSylvester();
					break;
			};
			_local3.destroy();
		}
		private function _onSylvesterComeIn(_arg1:Event):void{
			var _local2:HexTile;
			var _local3:Pickup;
			var _local4:MovieClip;
			_local2 = m_tileManager.getEmptyTile();
			if (_local2 != null){
				_local3 = m_pickupManager.getPow();
				m_pickupManager.insertItem(_local2.id, _local3);
				m_pickupManager.powLocation = _local2.id;
				_local4 = _local3.view;
				m_view.mc_pickupLayer.addChild(_local4);
				_local4.x = _local2.posX;
				_local4.y = _local2.posY;
				_local2.pickUpType = _local3.type;
				_local2.hasPickUp = true;
			};
		}
		private function _getRndTileWOAdjHole():HexTile{
			var _local1:uint;
			var _local2:uint;
			var _local3:HexTile;
			var _local4:Boolean;
			var _local5:uint;
			var _local6:Object;
			_local1 = 3;
			_local5 = 0;
			while (_local5 < _local1) {
				_local2 = Math.floor((m_completedTiles.length * Math.random()));
				_local3 = m_completedTiles[_local2];
				_local4 = true;
				for (_local6 in _local3.adjacentHexTiles) {
					if (HexTile(_local3.adjacentHexTiles[_local6]).state >= HexTileState.HOLE){
						_local4 = false;
						//unresolved jump
					};
				};
				if (_local4){
					break;
				};
				_local3 = null;
				_local5++;
			};
			return (_local3);
		}
		private function _onPickupDisappear(_arg1:PickupEvent):void{
			var _local2:HexTile;
			var _local3:Pickup;
			_local2 = m_tileManager.getTile(_arg1.hexTileId);
			_local2.hasPickUp = false;
			_local3 = m_pickupManager.getItem(_local2.id);
			m_pickupManager.removeItem(_local2.id);
			m_view.mc_pickupLayer.removeChild(_local3.view);
			_local3.destroy();
		}
		private function _powSylvester():void{
			var _local1:Array;
			var _local2:HexTile;
			var _local3:uint;
			m_enemy.hit();
			if (m_enemy.isSwiping){
				_local1 = _getSwipeTiles();
				_local3 = 0;
				while (_local3 < _local1.length) {
					_local2 = m_tileManager.getTile(_local1[_local3]);
					_local2.warningOver();
					_local3++;
				};
			};
		}
		private function _onSylvesterSwiped(_arg1:Event):void{
			var arr:Array;
			var ht:HexTile;
			var i:uint;
			var evt = _arg1;
			arr = _getSwipeTiles();
			i = 0;
			while (i < arr.length) {
				ht = m_tileManager.getTile(arr[i]);
				if (ht.occupied){
					m_character.inDanger(DangerType.SWIPE);
				};
				try {
					ht.warningOver();
				} catch(e:Error) {
				};
				i = (i + 1);
			};
		}
		private function _setNumLivesText():void{
			var _local1:String;
			_local1 = m_character.livesLeft.toString();
			if (_local1.length < 2){
				_local1 = ("0" + _local1);
			};
			m_view.txt_numLives.text = _local1;
		}
		public function get livesLeft():uint{
			return (m_character.livesLeft);
		}
		private function _setNumLevelText():void{
			var _local1:String;
			_local1 = m_level.toString();
			while (_local1.length < 3) {
				_local1 = ("0" + _local1);
			};
			m_view.txt_level.text = _local1;
		}
		private function _onSoundBtnClicked(_arg1:MouseEvent):void{
			var _local2:SoundManager;
			var _local3:MovieClip;
			_local2 = SoundManager.getInstance();
			_local2.mute(!(_local2.muted));
			_local3 = (_arg1.target as MovieClip);
			_local3.gotoAndStop((_local2.muted) ? 2 : 1);
		}
		private function _onTweetyStateChanged(_arg1:Event):void{
			if (((m_character.isOnEdge) && (!((m_character.tile.adjacentHexTiles["down"] == null))))){
				m_view.mc_characterEdgeLayer.addChild(m_character.getCurrentState().view);
			} else {
				m_view.mc_characterLayer.addChild(m_character.getCurrentState().view);
			};
		}
		private function _onEdgeTileDetected(_arg1:TileEvent):void{
			_arg1.edgeHexTile.dangerType = DangerType.EDGE;
			_arg1.edgeHexTile.isDangerous = true;
		}
		private function _onTweetyDeath(_arg1:Event):void{
			var _local2:SoundManager;
			_setNumLivesText();
			if (m_character.livesLeft > 0){
				m_character.tile = m_startTile;
				m_character.reappear();
			} else {
				_local2 = SoundManager.getInstance();
				_local2.stopAllSounds();
				_local2.stopLoop("Music_Main");
				_local2.playSound("Lose_SFX");
				this.dispatchEvent(new Event(LOST_GAME));
			};
		}
		private function _scorePoints(_arg1:Number):void{
			m_score = (m_score + _arg1);
			_setScoreText();
		}
		private function _hammerNailHoles():void{
			var _local1:HexTile;
			var _local2:Object;
			for (_local2 in m_holeTiles) {
				_local1 = (m_holeTiles[_local2] as HexTile);
				delete m_holeTiles[_local2];
				_local1.state = HexTileState.RECOVER;
				_local1.isDangerous = false;
			};
		}
		private function _onHoleGenTimer(_arg1:TimerEvent):void{
			var _local2:Number;
			var _local3:HexTile;
			if (m_completedTiles.length > 0){
				_local2 = Math.random();
				if (_local2 < m_holeGenProbability){
					_local3 = _getRndTileWOAdjHole();
					if (((((!((_local3 == m_startTile))) && (!((_local3 == null))))) && (_local3.isEmpty()))){
						_addHoleTile(_local3);
					};
				};
			};
		}
		private function _onDangerDelayed(_arg1:TimerEvent):void{
			m_dangerTimer.stop();
			if (m_dangerTimer.hasEventListener(TimerEvent.TIMER)){
				m_dangerTimer.removeEventListener(TimerEvent.TIMER, _onDangerDelayed);
			};
			m_dangerTimer = null;
			if (m_tileManager.tileHovered == m_dangerHT){
				if (((!(m_character.isMoving)) && (!(m_character.isDying)))){
					if (m_character.tile.isAdjacent(m_tileManager.tileHovered)){
						m_character.move(m_character.tile.relativeAdjPos, m_character.tile.targetTile);
					};
				};
			};
		}
		private function _getSwipeTiles():Array{
			var _local1:GameSettings;
			var _local2:Array;
			var _local3:Array;
			var _local4:Array;
			_local1 = GameSettings.getInstance(m_gameId);
			switch (m_enemy.attackMode){
				case Sylvester.MODE1:
					_local2 = [60, 61, 62, 63, 68, 69, 70, 71, 78];
					_local3 = [14, 20, 21, 22, 23, 28, 29, 30, 31];
					break;
				case Sylvester.MODE2:
					_local2 = [47, 54, 55, 62, 63, 70, 71, 78, 79];
					_local3 = [14, 15, 22, 23, 30, 31, 38, 39, 47];
					break;
			};
			if (m_enemy.side == Sylvester.RIGHT){
				_local4 = _local2;
			} else {
				_local4 = _local3;
			};
			return (_local4);
		}
		private function _addCompletedTile(_arg1:HexTile):void{
			m_completedTiles.push(_arg1);
			_arg1.state = HexTileState.COMPLETE;
		}
		private function _createPointAnimation(_arg1:HexTile, _arg2:int):void{
			var _local3:MovieClip;
			var _local4:PointAnimation;
			_local3 = _getSwfMovieClip("PointAnimationMC");
			_local4 = new PointAnimation(_local3, _arg1.id);
			_local4.addEventListener(PointAnimation.END, _onPointAnimationDone);
			m_pointAnimations[_arg1.id] = _local4;
			_local4.rollup(_arg2);
			m_view.mc_pointLayer.addChild(_local3);
			_local3.x = _arg1.posX;
			_local3.y = _arg1.posY;
		}
		private function _onSylvesterStateChanged(_arg1:Event):void{
			m_view.mc_enemyLayer.addChild(m_enemy.getCurrentState().view);
		}
		private function _onTileHovered(_arg1:Event):void{
			if (((!(m_character.isMoving)) && (!(m_character.isDying)))){
				if (m_character.tile.isAdjacent(m_tileManager.tileHovered)){
					if (((m_tileManager.tileHovered.isDangerous) && ((m_tileManager.tileHovered.dangerType == DangerType.EDGE)))){
						m_dangerHT = m_tileManager.tileHovered;
						if (m_dangerTimer){
							m_dangerTimer.stop();
							if (m_dangerTimer.hasEventListener(TimerEvent.TIMER)){
								m_dangerTimer.removeEventListener(TimerEvent.TIMER, _onDangerDelayed);
							};
							m_dangerTimer = null;
						};
						m_dangerTimer = new Timer(DANGER_DELAY_INTERVAL, 1);
						m_dangerTimer.addEventListener(TimerEvent.TIMER, _onDangerDelayed);
						m_dangerTimer.start();
					} else {
						m_character.move(m_character.tile.relativeAdjPos, m_character.tile.targetTile);
					};
				};
			};
		}
		private function _onTweetyCleanTile(_arg1:Event):void{
			var _local2:HexTile;
			SoundManager.getInstance().playSound("Tweety_Move_SFX");
			_local2 = m_character.tile;
			if (_local2.state < HexTileState.COMPLETE){
				_scorePoints(CLEANTILE_POINT);
				_local2.state = (_local2.state + 1);
				if (_local2.state == HexTileState.COMPLETE){
					_addCompletedTile(_local2);
					_checkGameWon();
				};
			};
		}
		private function _onSylvesterWarning(_arg1:Event):void{
			var arr:Array;
			var ht:HexTile;
			var i:uint;
			var evt = _arg1;
			arr = _getSwipeTiles();
			i = 0;
			while (i < arr.length) {
				ht = m_tileManager.getTile(arr[i]);
				if (ht.state <= HexTileState.COMPLETE){
					try {
						ht.warning();
					} catch(e:Error) {
					};
				};
				i = (i + 1);
			};
		}
		public function destroy():void{
			var _local1:PointAnimation;
			var _local2:Object;
			var _local3:uint;
			var _local4:Object;
			var _local5:MovieClip;
			var _local6:uint;
			m_holeGenTimer.stop();
			m_holeGenTimer.removeEventListener(TimerEvent.TIMER, _onHoleGenTimer);
			m_holeGenTimer = null;
			for (_local2 in m_pointAnimations) {
				_local1 = (m_pointAnimations[_local2] as PointAnimation);
				if (_local1.hasEventListener(PointAnimation.END)){
					_local1.removeEventListener(PointAnimation.END, _onPointAnimationDone);
				};
				delete m_pointAnimations[_local2];
				_local1.destroy();
			};
			if (m_dangerTimer){
				m_dangerTimer.stop();
				if (m_dangerTimer.hasEventListener(TimerEvent.TIMER)){
					m_dangerTimer.removeEventListener(TimerEvent.TIMER, _onDangerDelayed);
				};
				m_dangerTimer = null;
			};
			m_character.destroy();
			m_character.removeEventListener(TweetyBird.STATE_CHANGED, _onTweetyStateChanged);
			m_character.removeEventListener(TweetyBird.PICKUP_ITEM, _onTweetyPickupItem);
			m_character.removeEventListener(TweetyBird.CLEAN_TILE, _onTweetyCleanTile);
			m_character.removeEventListener(TweetyBird.DEATH, _onTweetyDeath);
			m_character = null;
			m_enemy.destroy();
			m_enemy.removeEventListener(Sylvester.STATE_CHANGED, _onSylvesterStateChanged);
			m_enemy.removeEventListener(Sylvester.SWIPE_WARNING, _onSylvesterWarning);
			m_enemy.removeEventListener(Sylvester.SWIPED, _onSylvesterSwiped);
			m_enemy.removeEventListener(Sylvester.COME_IN, _onSylvesterComeIn);
			m_enemy.removeEventListener(Sylvester.LEAVE, _onSylvesterLeft);
			m_enemy = null;
			m_pickupManager.destroy();
			m_pickupManager.removeEventListener(PickupManager.GENERATE, _onPickupGenerated);
			m_pickupManager.removeEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
			m_pickupManager = null;
			m_tileManager.destroy();
			m_tileManager.removeEventListener(TileManager.TILE_HOVERED, _onTileHovered);
			m_tileManager.removeEventListener(TileEvent.EDGE_DETECTED, _onEdgeTileDetected);
			m_tileManager = null;
			_local3 = 0;
			while (_local3 < m_completedTiles.length) {
				m_completedTiles[_local3] = null;
				_local3++;
			};
			m_completedTiles = null;
			for (_local4 in m_holeTiles) {
				delete m_holeTiles[_local4];
			};
			m_holeTiles = null;
			m_startTile = null;
			m_view.sound_btn.removeEventListener(MouseEvent.CLICK, _onSoundBtnClicked);
			_local5 = (m_view.mc_pickupLayer as MovieClip);
			while (_local5.numChildren) {
				_local5.removeChildAt(0);
			};
			_local5 = (m_view.mc_characterEdgeLayer as MovieClip);
			while (_local5.numChildren) {
				_local5.removeChildAt(0);
			};
			_local5 = (m_view.mc_characterLayer as MovieClip);
			while (_local5.numChildren) {
				_local5.removeChildAt(0);
			};
			_local5 = (m_view.mc_enemyLayer as MovieClip);
			while (_local5.numChildren) {
				_local5.removeChildAt(0);
			};
			_local5 = (m_view.mc_pointLayer as MovieClip);
			while (_local5.numChildren) {
				_local5.removeChildAt(0);
			};
			m_view = null;
		}
		private function _getSwfMovieClip(_arg1:String):MovieClip{
			var _local2:Class;
			_local2 = (m_screenHolders.loaderInfo.applicationDomain.getDefinition(_arg1) as Class);
			return ((new (_local2) as MovieClip));
		}

	}
}//package warnerbros.tweety 
Section 77
//InputManager (warnerbros.tweety.InputManager)
package warnerbros.tweety {
	import flash.display.*;
	import bigroom.input.*;

	public class InputManager extends KeyPoll {

		private static var c_instance:InputManager;

		public function InputManager(_arg1:DisplayObject, _arg2:SingletonEnforcer){
			super(_arg1);
		}
		public static function getInstance(_arg1:DisplayObject=null):InputManager{
			if (!c_instance){
				c_instance = new InputManager(_arg1, new SingletonEnforcer());
			};
			return (c_instance);
		}

	}
}//package warnerbros.tweety 

class SingletonEnforcer {

	private function SingletonEnforcer(){
	}
}
Section 78
//PauseableTimer (warnerbros.tweety.PauseableTimer)
package warnerbros.tweety {
	import flash.utils.*;

	public class PauseableTimer {

		private var m_paused:Boolean;
		private var m_timeStarted:Number;
		private var m_Id:Number;
		private var m_callBack:Function;
		private var m_time:Number;

		public function PauseableTimer(_arg1:Number){
			m_time = _arg1;
			m_Id = 0;
		}
		private function _onWaitTimerComplete():void{
			if (m_callBack != null){
				m_callBack();
			};
		}
		public function start():void{
			var _local1:Number;
			_local1 = m_Id;
			m_Id = setTimeout(_onWaitTimerComplete, m_time);
			m_timeStarted = getTimer();
			m_paused = false;
		}
		public function set callBackFc(_arg1:Function):void{
			m_callBack = _arg1;
		}
		public function get isPaused():Boolean{
			return (m_paused);
		}
		public function destroy():void{
			clearTimeout(m_Id);
			m_Id = 0;
		}
		public function timeLeft():Number{
			return (((m_time + m_timeStarted) - getTimer()));
		}
		public function pauseTimer(_arg1:Boolean):void{
			if (_arg1){
				m_paused = true;
				m_time = (m_time - (getTimer() - m_timeStarted));
				if (m_time < 0){
					m_time = 0;
				};
				clearTimeout(m_Id);
			} else {
				m_paused = false;
				start();
			};
		}

	}
}//package warnerbros.tweety 
Section 79
//PickupManager (warnerbros.tweety.PickupManager)
package warnerbros.tweety {
	import flash.events.*;
	import flash.display.*;
	import warnerbros.tweety.data.*;
	import warnerbros.tweety.events.*;
	import flash.utils.*;

	public class PickupManager extends EventDispatcher {

		private var m_hammerAppProbability:Number;
		private var m_currentPickups:Dictionary;
		private var m_gameMC:MovieClip;
		private var m_powLocation:uint;
		private var m_hammerExisted:Boolean;
		private var m_generateInterval:Number;
		private var m_generateTimer:Timer;

		public static const GENERATE:String = "pickupmanager_generate";

		public function PickupManager(_arg1:MovieClip, _arg2:Number){
			var _local3:uint;
			super();
			m_gameMC = _arg1;
			m_currentPickups = new Dictionary();
			m_hammerExisted = false;
			m_generateInterval = (_arg2 * 1000);
			_local3 = (Math.floor((m_generateInterval * Math.random())) + 1);
			m_generateTimer = new Timer(_local3);
			m_generateTimer.addEventListener(TimerEvent.TIMER, _onGenerateTimer);
			m_generateTimer.start();
		}
		public function insertItem(_arg1:uint, _arg2:Pickup):void{
			m_currentPickups[_arg1] = _arg2;
			_arg2.id = _arg1;
			_arg2.appear();
		}
		public function get powLocation():uint{
			return (m_powLocation);
		}
		public function destroy():void{
			var _local1:Pickup;
			var _local2:Object;
			m_gameMC = null;
			m_generateTimer.stop();
			m_generateTimer.removeEventListener(TimerEvent.TIMER, _onGenerateTimer);
			m_generateTimer = null;
			for (_local2 in m_currentPickups) {
				_local1 = (m_currentPickups[_local2] as Pickup);
				_local1.destroy();
				if (_local1.hasEventListener(Pickup.DISAPPEAR)){
					_local1.removeEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
				};
				delete m_currentPickups[_local2];
			};
		}
		public function get hammerAppProbability():Number{
			return (m_hammerAppProbability);
		}
		public function set powLocation(_arg1:uint):void{
			m_powLocation = _arg1;
		}
		public function removePow():void{
			this.dispatchEvent(new PickupEvent(Pickup.DISAPPEAR, m_powLocation));
		}
		public function hammerItemAvailable():void{
			m_hammerExisted = false;
		}
		public function getItem(_arg1:uint):Pickup{
			return ((m_currentPickups[_arg1] as Pickup));
		}
		public function getPow():Pickup{
			var _local1:MovieClip;
			var _local2:Pickup;
			_local1 = _getPickupView(PickupType.POW);
			_local2 = new Pickup(_local1, PickupType.POW);
			_local2.addEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
			return (_local2);
		}
		public function getNewPickup():Pickup{
			var _local1:uint;
			var _local2:Number;
			var _local3:MovieClip;
			var _local4:Pickup;
			if (m_hammerExisted){
				_local2 = (Math.floor((Math.random() * 3)) + 1);
				switch (_local2){
					case 1:
						_local1 = PickupType.BONUS1;
						break;
					case 2:
						_local1 = PickupType.BONUS2;
						break;
					case 3:
						_local1 = PickupType.BONUS3;
						break;
				};
			} else {
				_local2 = Math.random();
				if (_local2 < m_hammerAppProbability){
					_local1 = PickupType.HAMMER_NAIL;
					m_hammerExisted = true;
				} else {
					_local2 = (Math.floor((Math.random() * 3)) + 1);
					switch (_local2){
						case 1:
							_local1 = PickupType.BONUS1;
							break;
						case 2:
							_local1 = PickupType.BONUS2;
							break;
						case 3:
							_local1 = PickupType.BONUS3;
							break;
					};
				};
			};
			_local3 = _getPickupView(_local1);
			_local4 = new Pickup(_local3, _local1);
			_local4.addEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
			return (_local4);
		}
		private function _onPickupDisappear(_arg1:Event):void{
			var _local2:Pickup;
			_local2 = (_arg1.target as Pickup);
			if (_local2.type == PickupType.HAMMER_NAIL){
				m_hammerExisted = false;
			};
			this.dispatchEvent(new PickupEvent(Pickup.DISAPPEAR, _local2.id));
		}
		public function set hammerAppProbability(_arg1:Number):void{
			m_hammerAppProbability = _arg1;
		}
		private function _onGenerateTimer(_arg1:TimerEvent):void{
			var _local2:uint;
			_local2 = (Math.floor((m_generateInterval * Math.random())) + 1);
			m_generateTimer.delay = _local2;
			this.dispatchEvent(new Event(GENERATE));
		}
		private function _getSwfMovieClip(_arg1:String):MovieClip{
			var _local2:Class;
			_local2 = (m_gameMC.loaderInfo.applicationDomain.getDefinition(_arg1) as Class);
			return ((new (_local2) as MovieClip));
		}
		public function removeItem(_arg1:uint):void{
			this.getItem(_arg1).removeEventListener(Pickup.DISAPPEAR, _onPickupDisappear);
			delete m_currentPickups[_arg1];
		}
		private function _getPickupView(_arg1:uint):MovieClip{
			var _local2:MovieClip;
			switch (_arg1){
				case PickupType.BONUS1:
					_local2 = _getSwfMovieClip("Bonus1");
					break;
				case PickupType.BONUS2:
					_local2 = _getSwfMovieClip("Bonus2");
					break;
				case PickupType.BONUS3:
					_local2 = _getSwfMovieClip("Bonus3");
					break;
				case PickupType.HAMMER_NAIL:
					_local2 = _getSwfMovieClip("Hammer");
					break;
				case PickupType.POW:
					_local2 = _getSwfMovieClip("Pow");
					break;
			};
			return (_local2);
		}

	}
}//package warnerbros.tweety 
Section 80
//SoundManager (warnerbros.tweety.SoundManager)
package warnerbros.tweety {
	import flash.events.*;
	import flash.media.*;
	import flash.utils.*;

	public class SoundManager {

		private var m_playingSounds:Dictionary;
		private var m_muted:Boolean;// = false
		private var m_soundClasses:Dictionary;
		private var m_playingLoops:Dictionary;
		private var m_isPlaying:Boolean;

		private static var c_instance:SoundManager;

		public function SoundManager(_arg1:SingletonEnforcer){
			m_muted = false;
			super();
			m_soundClasses = new Dictionary();
			m_playingSounds = new Dictionary();
			m_playingLoops = new Dictionary();
			m_isPlaying = true;
		}
		public function addSoundClass(_arg1:String, _arg2:Class):void{
			m_soundClasses[_arg1] = _arg2;
		}
		public function stopAllSounds():void{
			var _local1:SoundChannel;
			var _local2:Object;
			for (_local2 in m_playingSounds) {
				_local1 = (m_playingSounds[_local2] as SoundChannel);
				_local1.stop();
				if (_local1.hasEventListener(Event.SOUND_COMPLETE)){
					_local1.removeEventListener(Event.SOUND_COMPLETE, _removeSound);
				};
				_local1 = null;
				delete m_playingSounds[_local2];
			};
		}
		public function get isPlaying():Boolean{
			return (m_isPlaying);
		}
		private function _removeSound(_arg1:Event):void{
			delete m_playingSounds[_arg1.target];
		}
		public function stopLoop(_arg1:String):void{
			if (m_playingLoops[_arg1] != null){
				m_playingLoops[_arg1].stop();
				delete m_playingLoops[_arg1];
			};
		}
		public function mute(_arg1:Boolean):void{
			var _local2:SoundTransform;
			var _local3:*;
			var _local4:*;
			m_muted = _arg1;
			_local2 = new SoundTransform((_arg1) ? 0 : 1);
			for (_local3 in m_playingLoops) {
				m_playingLoops[_local3].soundTransform = _local2;
			};
			for (_local4 in m_playingSounds) {
				m_playingSounds[_local4].soundTransform = _local2;
			};
		}
		public function set isPlaying(_arg1:Boolean):void{
			var _local2:*;
			m_isPlaying = _arg1;
			if (_arg1 == false){
				for (_local2 in m_playingLoops) {
					m_playingLoops[_local2].stop();
					delete m_playingLoops[_local2];
				};
			};
		}
		public function playLoop(_arg1:String):void{
			var _local2:Sound;
			if (m_isPlaying){
				if (m_playingLoops[_arg1] == null){
					_local2 = (new (m_soundClasses[_arg1]) as Sound);
					m_playingLoops[_arg1] = _local2.play(0, 999999);
					m_playingLoops[_arg1].soundTransform = new SoundTransform((m_muted) ? 0 : 1);
				};
			};
		}
		public function playSound(_arg1:String):void{
			var _local2:Sound;
			if (m_isPlaying){
				_local2 = (new (m_soundClasses[_arg1]) as Sound);
				m_playingSounds[_local2] = _local2.play();
				m_playingSounds[_local2].soundTransform = new SoundTransform((m_muted) ? 0 : 1);
				m_playingSounds[_local2].addEventListener(Event.SOUND_COMPLETE, _removeSound);
			};
		}
		public function get muted():Boolean{
			return (m_muted);
		}

		public static function getInstance():SoundManager{
			if (!c_instance){
				c_instance = new SoundManager(new SingletonEnforcer());
			};
			return (c_instance);
		}

	}
}//package warnerbros.tweety 

class SingletonEnforcer {

	private function SingletonEnforcer(){
	}
}
Section 81
//Appear_cat_SFX (Appear_cat_SFX)
package {
	import flash.media.*;

	public dynamic class Appear_cat_SFX extends Sound {

	}
}//package 
Section 82
//BetweenLevelScreenMC (BetweenLevelScreenMC)
package {
	import flash.display.*;

	public dynamic class BetweenLevelScreenMC extends MovieClip {

		public var mc_bg:MovieClip;
		public var mc_level:MovieClip;

	}
}//package 
Section 83
//Bird_FallEdge (Bird_FallEdge)
package {
	import flash.display.*;

	public dynamic class Bird_FallEdge extends MovieClip {

		public function Bird_FallEdge(){
			addFrameScript(12, frame13);
		}
		function frame13(){
			stop();
		}

	}
}//package 
Section 84
//Bird_FallHole (Bird_FallHole)
package {
	import flash.display.*;

	public dynamic class Bird_FallHole extends MovieClip {

		public function Bird_FallHole(){
			addFrameScript(14, frame15);
		}
		function frame15(){
			stop();
		}

	}
}//package 
Section 85
//Bird_Hit (Bird_Hit)
package {
	import flash.display.*;

	public dynamic class Bird_Hit extends MovieClip {

		public function Bird_Hit(){
			addFrameScript(9, frame10);
		}
		function frame10(){
			stop();
		}

	}
}//package 
Section 86
//Bird_Idle (Bird_Idle)
package {
	import flash.display.*;

	public dynamic class Bird_Idle extends MovieClip {

	}
}//package 
Section 87
//Bird_IdleBack (Bird_IdleBack)
package {
	import flash.display.*;

	public dynamic class Bird_IdleBack extends MovieClip {

	}
}//package 
Section 88
//Bird_JumpDown (Bird_JumpDown)
package {
	import flash.display.*;

	public dynamic class Bird_JumpDown extends MovieClip {

		public function Bird_JumpDown(){
			addFrameScript(6, frame7);
		}
		function frame7(){
			stop();
		}

	}
}//package 
Section 89
//Bird_JumpSide (Bird_JumpSide)
package {
	import flash.display.*;

	public dynamic class Bird_JumpSide extends MovieClip {

		public function Bird_JumpSide(){
			addFrameScript(6, frame7);
		}
		function frame7(){
			stop();
		}

	}
}//package 
Section 90
//Bird_JumpUp (Bird_JumpUp)
package {
	import flash.display.*;

	public dynamic class Bird_JumpUp extends MovieClip {

		public function Bird_JumpUp(){
			addFrameScript(6, frame7);
		}
		function frame7(){
			stop();
		}

	}
}//package 
Section 91
//Bird_PowerUp (Bird_PowerUp)
package {
	import flash.display.*;

	public dynamic class Bird_PowerUp extends MovieClip {

		public function Bird_PowerUp(){
			addFrameScript(5, frame6);
		}
		function frame6(){
			stop();
		}

	}
}//package 
Section 92
//Bird_Reappear (Bird_Reappear)
package {
	import flash.display.*;

	public dynamic class Bird_Reappear extends MovieClip {

		public function Bird_Reappear(){
			addFrameScript(13, frame14);
		}
		function frame14(){
			stop();
		}

	}
}//package 
Section 93
//Bonus_SFX (Bonus_SFX)
package {
	import flash.media.*;

	public dynamic class Bonus_SFX extends Sound {

	}
}//package 
Section 94
//Bonus1 (Bonus1)
package {
	import flash.display.*;

	public dynamic class Bonus1 extends MovieClip {

	}
}//package 
Section 95
//Bonus2 (Bonus2)
package {
	import flash.display.*;

	public dynamic class Bonus2 extends MovieClip {

	}
}//package 
Section 96
//Bonus3 (Bonus3)
package {
	import flash.display.*;

	public dynamic class Bonus3 extends MovieClip {

	}
}//package 
Section 97
//EndScreenMC (EndScreenMC)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class EndScreenMC extends MovieClip {

		public var playAgain_btn:MovieClip;
		public var score_tf:TextField;

	}
}//package 
Section 98
//GameScreenMC (GameScreenMC)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class GameScreenMC extends MovieClip {

		public var txt_level:TextField;
		public var txt_numLives:TextField;
		public var txt_score:TextField;
		public var mc_pickupLayer:MovieClip;
		public var mc_hitzone:MovieClip;
		public var sound_btn:MovieClip;
		public var mc_characterLayer:MovieClip;
		public var mc_bg:MovieClip;
		public var mc_characterEdgeLayer:MovieClip;
		public var mc_tiles:MovieClip;
		public var mc_pointLayer:MovieClip;
		public var mc_enemyLayer:MovieClip;

	}
}//package 
Section 99
//Hammer (Hammer)
package {
	import flash.display.*;

	public dynamic class Hammer extends MovieClip {

	}
}//package 
Section 100
//HammerNails_SFX (HammerNails_SFX)
package {
	import flash.media.*;

	public dynamic class HammerNails_SFX extends Sound {

	}
}//package 
Section 101
//Hole_crash_SFX (Hole_crash_SFX)
package {
	import flash.media.*;

	public dynamic class Hole_crash_SFX extends Sound {

	}
}//package 
Section 102
//InstructionScreenMC (InstructionScreenMC)
package {
	import flash.display.*;

	public dynamic class InstructionScreenMC extends MovieClip {

		public var back_btn:MovieClip;
		public var page_mc:MovieClip;
		public var play_btn:MovieClip;
		public var forward_btn:MovieClip;

	}
}//package 
Section 103
//Lose_SFX (Lose_SFX)
package {
	import flash.media.*;

	public dynamic class Lose_SFX extends Sound {

	}
}//package 
Section 104
//Music_Intro (Music_Intro)
package {
	import flash.media.*;

	public dynamic class Music_Intro extends Sound {

	}
}//package 
Section 105
//Music_Main (Music_Main)
package {
	import flash.media.*;

	public dynamic class Music_Main extends Sound {

	}
}//package 
Section 106
//Pause_SFX (Pause_SFX)
package {
	import flash.media.*;

	public dynamic class Pause_SFX extends Sound {

	}
}//package 
Section 107
//PointAnimationMC (PointAnimationMC)
package {
	import flash.display.*;

	public dynamic class PointAnimationMC extends MovieClip {

		public var point_mc:MovieClip;

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

	}
}//package 
Section 108
//Pow (Pow)
package {
	import flash.display.*;

	public dynamic class Pow extends MovieClip {

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

	}
}//package 
Section 109
//POW_Idle_SFX (POW_Idle_SFX)
package {
	import flash.media.*;

	public dynamic class POW_Idle_SFX extends Sound {

	}
}//package 
Section 110
//POW_Swiping_SFX (POW_Swiping_SFX)
package {
	import flash.media.*;

	public dynamic class POW_Swiping_SFX extends Sound {

	}
}//package 
Section 111
//SplashScreenMC (SplashScreenMC)
package {
	import flash.display.*;

	public dynamic class SplashScreenMC extends MovieClip {

		public var instructions_btn:MovieClip;
		public var play_btn:MovieClip;

	}
}//package 
Section 112
//Swipe_SFX (Swipe_SFX)
package {
	import flash.media.*;

	public dynamic class Swipe_SFX extends Sound {

	}
}//package 
Section 113
//Sylvester_ComeIn (Sylvester_ComeIn)
package {
	import flash.display.*;

	public dynamic class Sylvester_ComeIn extends MovieClip {

		public function Sylvester_ComeIn(){
			addFrameScript(54, frame55);
		}
		function frame55(){
			stop();
		}

	}
}//package 
Section 114
//Sylvester_Hit (Sylvester_Hit)
package {
	import flash.display.*;

	public dynamic class Sylvester_Hit extends MovieClip {

		public function Sylvester_Hit(){
			addFrameScript(75, frame76);
		}
		function frame76(){
			stop();
		}

	}
}//package 
Section 115
//Sylvester_HitSwiping (Sylvester_HitSwiping)
package {
	import flash.display.*;

	public dynamic class Sylvester_HitSwiping extends MovieClip {

		public function Sylvester_HitSwiping(){
			addFrameScript(65, frame66);
		}
		function frame66(){
			stop();
		}

	}
}//package 
Section 116
//Sylvester_Idle (Sylvester_Idle)
package {
	import flash.display.*;

	public dynamic class Sylvester_Idle extends MovieClip {

	}
}//package 
Section 117
//Sylvester_Leave (Sylvester_Leave)
package {
	import flash.display.*;

	public dynamic class Sylvester_Leave extends MovieClip {

		public function Sylvester_Leave(){
			addFrameScript(42, frame43);
		}
		function frame43(){
			stop();
		}

	}
}//package 
Section 118
//Sylvester_Peek1 (Sylvester_Peek1)
package {
	import flash.display.*;

	public dynamic class Sylvester_Peek1 extends MovieClip {

		public function Sylvester_Peek1(){
			addFrameScript(78, frame79);
		}
		function frame79(){
			stop();
		}

	}
}//package 
Section 119
//Sylvester_Peek2 (Sylvester_Peek2)
package {
	import flash.display.*;

	public dynamic class Sylvester_Peek2 extends MovieClip {

		public function Sylvester_Peek2(){
			addFrameScript(115, frame116);
		}
		function frame116(){
			stop();
		}

	}
}//package 
Section 120
//Sylvester_Peek3 (Sylvester_Peek3)
package {
	import flash.display.*;

	public dynamic class Sylvester_Peek3 extends MovieClip {

		public function Sylvester_Peek3(){
			addFrameScript(54, frame55);
		}
		function frame55(){
			stop();
		}

	}
}//package 
Section 121
//Sylvester_Peek4 (Sylvester_Peek4)
package {
	import flash.display.*;

	public dynamic class Sylvester_Peek4 extends MovieClip {

		public function Sylvester_Peek4(){
			addFrameScript(115, frame116);
		}
		function frame116(){
			stop();
		}

	}
}//package 
Section 122
//Sylvester_Swipe1 (Sylvester_Swipe1)
package {
	import flash.display.*;

	public dynamic class Sylvester_Swipe1 extends MovieClip {

		public function Sylvester_Swipe1(){
			addFrameScript(13, frame14);
		}
		function frame14(){
			stop();
		}

	}
}//package 
Section 123
//Sylvester_Swipe2 (Sylvester_Swipe2)
package {
	import flash.display.*;

	public dynamic class Sylvester_Swipe2 extends MovieClip {

		public function Sylvester_Swipe2(){
			addFrameScript(13, frame14);
		}
		function frame14(){
			stop();
		}

	}
}//package 
Section 124
//Sylvester_Wait1 (Sylvester_Wait1)
package {
	import flash.display.*;

	public dynamic class Sylvester_Wait1 extends MovieClip {

		public function Sylvester_Wait1(){
			addFrameScript(8, frame9);
		}
		function frame9(){
			stop();
		}

	}
}//package 
Section 125
//Sylvester_Wait2 (Sylvester_Wait2)
package {
	import flash.display.*;

	public dynamic class Sylvester_Wait2 extends MovieClip {

		public function Sylvester_Wait2(){
			addFrameScript(8, frame9);
		}
		function frame9(){
			stop();
		}

	}
}//package 
Section 126
//Tweety (Tweety)
package {
	import warnerbros.tweety.*;
	import flash.events.*;
	import flash.display.*;
	import peach.core.*;
	import warnerbros.tweety.events.*;
	import flash.net.*;
	import peach.config.*;
	import warnerbros.tweety.screens.*;

	public class Tweety extends Game {

		private var m_betweenLevelScreen:BetweenLevelScreen;
		private var m_gameOverScreen:GameOverScreen;
		private var m_level:uint;
		private var m_splashScreen:SplashScreen;
		private var m_mainClip:MovieClip;
		private var m_livesLeft:uint;
		private var m_score:int;
		private var m_prevScreen:MovieClip;
		private var m_gameSettings:GameSettings;
		private var m_manager:GameManager;

		public function Tweety(){
			super("Tweety");
			this.stage.scaleMode = StageScaleMode.NO_SCALE;
			this.stage.align = StageAlign.TOP_LEFT;
			this.stage.focus = this;
			m_level = 1;
			m_score = 0;
			m_livesLeft = 3;
			start();
		}
		private function _initializeClassValues():void{
			InputManager.getInstance(this.stage);
			m_gameSettings = GameSettings.getInstance(this.id);
		}
		private function _onStartGameFromInstructions(_arg1:Event):void{
			_arg1.target.removeEventListener(InstructionsScreen.START_GAME, _onStartGameFromInstructions);
			startGame(_arg1.target.view);
		}
		public function getIntegratedSwfMovieClip(_arg1:String):MovieClip{
			var _local2:Class;
			_local2 = (this.loaderInfo.applicationDomain.getDefinition(_arg1) as Class);
			return ((new (_local2) as MovieClip));
		}
		private function _onStartGameFromGameOver(_arg1:StartGameEvent):void{
			m_gameOverScreen.removeEventListener(GameOverScreen.START_GAME, _onStartGameFromGameOver);
			m_gameOverScreen = null;
			m_level = 1;
			m_score = 0;
			m_livesLeft = 3;
			startGame(_arg1.target.view);
		}
		override public function start():void{
			try {
				this.removeChild(this.preloaderView);
				this.preloaderView = null;
			} catch(e:Error) {
			};
			_initializeClassValues();
			_prepareSoundLibrary();
			_showSplashScreen();
		}
		public function startGame(_arg1:MovieClip):void{
			m_prevScreen = _arg1;
			if (m_mainClip == null){
				m_mainClip = getIntegratedSwfMovieClip("GameScreenMC");
				addChild(m_mainClip);
				m_mainClip.visible = false;
				m_mainClip.addEventListener(Event.ENTER_FRAME, _mainClipEnterFrame);
			} else {
				_mainClipReady();
			};
		}
		private function _mainClipReady():void{
			m_mainClip.visible = true;
			removeChild(m_prevScreen);
			m_prevScreen = null;
			m_manager = new GameManager(m_mainClip, this, this.id, m_level, m_score, m_livesLeft);
			m_manager.addEventListener(GameManager.WON_GAME, _onGameWon);
			m_manager.addEventListener(GameManager.LOST_GAME, _onGameLost);
			m_manager.addEventListener(GameManager.NEXT_LEVEL, _onNextLevel);
			SoundManager.getInstance().stopAllSounds();
			SoundManager.getInstance().playLoop("Music_Main");
		}
		private function _prepareSoundLibrary():void{
			var _local1:Function;
			var _local2:Function;
			_local1 = SoundManager.getInstance().addSoundClass;
			_local2 = this.loaderInfo.applicationDomain.getDefinition;
			_local1("Tweety_Move_SFX", (_local2("Tweety_Move_SFX") as Class));
			_local1("Tweety_Fall_SFX", (_local2("Tweety_Fall_SFX") as Class));
			_local1("Bonus_SFX", (_local2("Bonus_SFX") as Class));
			_local1("POW_Swiping_SFX", (_local2("POW_Swiping_SFX") as Class));
			_local1("POW_Idle_SFX", (_local2("POW_Idle_SFX") as Class));
			_local1("HammerNails_SFX", (_local2("HammerNails_SFX") as Class));
			_local1("Hole_crash_SFX", (_local2("Hole_crash_SFX") as Class));
			_local1("Swipe_SFX", (_local2("Swipe_SFX") as Class));
			_local1("Lose_SFX", (_local2("Lose_SFX") as Class));
			_local1("Win_SFX", (_local2("Win_SFX") as Class));
			_local1("UI_Click_SFX", (_local2("UI_Click_SFX") as Class));
			_local1("Pause_SFX", (_local2("Pause_SFX") as Class));
			_local1("Music_Intro", (_local2("Music_Intro") as Class));
			_local1("Music_Main", (_local2("Music_Main") as Class));
		}
		private function _showSplashScreen():void{
			var _local1:MovieClip;
			_local1 = getIntegratedSwfMovieClip("SplashScreenMC");
			m_splashScreen = new SplashScreen(_local1);
			m_splashScreen.addEventListener(SplashScreen.START_GAME, _onStartGame);
			m_splashScreen.addEventListener(SplashScreen.SHOW_INSTRUCTIONS, _onShowInstructions);
			addChild(_local1);
			SoundManager.getInstance().playSound("Music_Intro");
		}
		private function _mainClipEnterFrame(_arg1:Event):void{
			m_mainClip.removeEventListener(Event.ENTER_FRAME, _mainClipEnterFrame);
			_mainClipReady();
		}
		private function _onNextLevel(_arg1:Event):void{
			var _local2:MovieClip;
			m_level = (m_manager.level + 1);
			m_score = m_manager.score;
			m_livesLeft = m_manager.livesLeft;
			m_manager.destroy();
			m_manager.removeEventListener(GameManager.WON_GAME, _onGameWon);
			m_manager.removeEventListener(GameManager.LOST_GAME, _onGameLost);
			m_manager.removeEventListener(GameManager.NEXT_LEVEL, _onNextLevel);
			m_manager = null;
			removeChild(m_mainClip);
			m_mainClip = null;
			_local2 = getIntegratedSwfMovieClip("BetweenLevelScreenMC");
			m_betweenLevelScreen = new BetweenLevelScreen(_local2, m_level);
			m_betweenLevelScreen.addEventListener(BetweenLevelScreen.CONTINUE, _onContinueGame);
			addChild(_local2);
		}
		public function getSwfMovieClip(_arg1:String):MovieClip{
			var _local2:AssetsNode;
			_local2 = AssetsLibrary.getLibrary(this.id).getNode("startup");
			return (_local2.getMovieClip(_arg1));
		}
		private function _onStartGame(_arg1:StartGameEvent):void{
			if ((_arg1.target is SplashScreen)){
				m_splashScreen.removeEventListener(SplashScreen.START_GAME, _onStartGame);
				m_splashScreen.removeEventListener(SplashScreen.SHOW_INSTRUCTIONS, _onShowInstructions);
				m_splashScreen.destroy();
			};
			startGame(_arg1.target.view);
		}
		private function _onGameLost(_arg1:Event):void{
			_showGameOverScreen(false);
		}
		private function _onContinueGame(_arg1:Event):void{
			_arg1.target.removeEventListener(BetweenLevelScreen.CONTINUE, _onContinueGame);
			startGame(_arg1.target.view);
		}
		private function _onShowInstructions(_arg1:Event):void{
			var _local2:MovieClip;
			var _local3:InstructionsScreen;
			_arg1.target.removeEventListener(SplashScreen.START_GAME, _onStartGame);
			_arg1.target.removeEventListener(SplashScreen.SHOW_INSTRUCTIONS, _onShowInstructions);
			removeChild(_arg1.target.view);
			_local2 = getIntegratedSwfMovieClip("InstructionScreenMC");
			_local3 = new InstructionsScreen(_local2);
			_local3.addEventListener(InstructionsScreen.START_GAME, _onStartGameFromInstructions);
			addChild(_local2);
		}
		public function getXml(_arg1:String):XML{
			var _local2:AssetsNode;
			_local2 = AssetsLibrary.getLibrary(this.id).getNode("startup");
			return (_local2.getXML(_arg1));
		}
		private function _onGameWon(_arg1:Event):void{
			_showGameOverScreen(true);
		}
		private function _showGameOverScreen(_arg1:Boolean):void{
			var _local2:Number;
			var _local3:LocalConnection;
			var _local4:MovieClip;
			_local2 = m_manager.score;
			m_manager.destroy();
			m_manager.removeEventListener(GameManager.WON_GAME, _onGameWon);
			m_manager.removeEventListener(GameManager.LOST_GAME, _onGameLost);
			m_manager.removeEventListener(GameManager.NEXT_LEVEL, _onNextLevel);
			m_manager = null;
			removeChild(m_mainClip);
			m_mainClip = null;
			_local3 = new LocalConnection();
			_local3.send("_user", "fnPostScore", _local2);
			_local4 = getIntegratedSwfMovieClip("EndScreenMC");
			m_gameOverScreen = new GameOverScreen(_local4, _arg1, _local2);
			m_gameOverScreen.addEventListener(GameOverScreen.START_GAME, _onStartGameFromGameOver);
			addChild(_local4);
		}

	}
}//package 
Section 127
//Tweety_Fall_SFX (Tweety_Fall_SFX)
package {
	import flash.media.*;

	public dynamic class Tweety_Fall_SFX extends Sound {

	}
}//package 
Section 128
//Tweety_Move_SFX (Tweety_Move_SFX)
package {
	import flash.media.*;

	public dynamic class Tweety_Move_SFX extends Sound {

	}
}//package 
Section 129
//UI_Click_SFX (UI_Click_SFX)
package {
	import flash.media.*;

	public dynamic class UI_Click_SFX extends Sound {

	}
}//package 
Section 130
//Win_SFX (Win_SFX)
package {
	import flash.media.*;

	public dynamic class Win_SFX extends Sound {

	}
}//package