(function (console) { "use strict";
var $hxClasses = {},$estr = function() { return js_Boot.__string_rec(this,''); };
function $extend(from, fields) {
	function Inherit() {} Inherit.prototype = from; var proto = new Inherit();
	for (var name in fields) proto[name] = fields[name];
	if( fields.toString !== Object.prototype.toString ) proto.toString = fields.toString;
	return proto;
}
var EReg = function(r,opt) {
	opt = opt.split("u").join("");
	this.r = new RegExp(r,opt);
};
$hxClasses["EReg"] = EReg;
EReg.__name__ = ["EReg"];
EReg.prototype = {
	match: function(s) {
		if(this.r.global) this.r.lastIndex = 0;
		this.r.m = this.r.exec(s);
		this.r.s = s;
		return this.r.m != null;
	}
	,matched: function(n) {
		if(this.r.m != null && n >= 0 && n < this.r.m.length) return this.r.m[n]; else throw new js__$Boot_HaxeError("EReg::matched");
	}
	,replace: function(s,by) {
		return s.replace(this.r,by);
	}
	,__class__: EReg
};
var HxOverrides = function() { };
$hxClasses["HxOverrides"] = HxOverrides;
HxOverrides.__name__ = ["HxOverrides"];
HxOverrides.cca = function(s,index) {
	var x = s.charCodeAt(index);
	if(x != x) return undefined;
	return x;
};
HxOverrides.substr = function(s,pos,len) {
	if(pos != null && pos != 0 && len != null && len < 0) return "";
	if(len == null) len = s.length;
	if(pos < 0) {
		pos = s.length + pos;
		if(pos < 0) pos = 0;
	} else if(len < 0) len = s.length + len - pos;
	return s.substr(pos,len);
};
HxOverrides.indexOf = function(a,obj,i) {
	var len = a.length;
	if(i < 0) {
		i += len;
		if(i < 0) i = 0;
	}
	while(i < len) {
		if(a[i] === obj) return i;
		i++;
	}
	return -1;
};
HxOverrides.iter = function(a) {
	return { cur : 0, arr : a, hasNext : function() {
		return this.cur < this.arr.length;
	}, next : function() {
		return this.arr[this.cur++];
	}};
};
var Lambda = function() { };
$hxClasses["Lambda"] = Lambda;
Lambda.__name__ = ["Lambda"];
Lambda.exists = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		if(f(x)) return true;
	}
	return false;
};
Lambda.foreach = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		if(!f(x)) return false;
	}
	return true;
};
Lambda.fold = function(it,f,first) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		first = f(x,first);
	}
	return first;
};
Lambda.find = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var v = $it0.next();
		if(f(v)) return v;
	}
	return null;
};
Math.__name__ = ["Math"];
var Reflect = function() { };
$hxClasses["Reflect"] = Reflect;
Reflect.__name__ = ["Reflect"];
Reflect.field = function(o,field) {
	try {
		return o[field];
	} catch( e ) {
		if (e instanceof js__$Boot_HaxeError) e = e.val;
		return null;
	}
};
Reflect.setField = function(o,field,value) {
	o[field] = value;
};
Reflect.fields = function(o) {
	var a = [];
	if(o != null) {
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		for( var f in o ) {
		if(f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o,f)) a.push(f);
		}
	}
	return a;
};
var Std = function() { };
$hxClasses["Std"] = Std;
Std.__name__ = ["Std"];
Std["is"] = function(v,t) {
	return js_Boot.__instanceof(v,t);
};
Std.string = function(s) {
	return js_Boot.__string_rec(s,"");
};
Std["int"] = function(x) {
	return x | 0;
};
Std.parseInt = function(x) {
	var v = parseInt(x,10);
	if(v == 0 && (HxOverrides.cca(x,1) == 120 || HxOverrides.cca(x,1) == 88)) v = parseInt(x);
	if(isNaN(v)) return null;
	return v;
};
var Type = function() { };
$hxClasses["Type"] = Type;
Type.__name__ = ["Type"];
Type.getClassName = function(c) {
	var a = c.__name__;
	if(a == null) return null;
	return a.join(".");
};
Type.resolveClass = function(name) {
	var cl = $hxClasses[name];
	if(cl == null || !cl.__name__) return null;
	return cl;
};
Type.createInstance = function(cl,args) {
	var _g = args.length;
	switch(_g) {
	case 0:
		return new cl();
	case 1:
		return new cl(args[0]);
	case 2:
		return new cl(args[0],args[1]);
	case 3:
		return new cl(args[0],args[1],args[2]);
	case 4:
		return new cl(args[0],args[1],args[2],args[3]);
	case 5:
		return new cl(args[0],args[1],args[2],args[3],args[4]);
	case 6:
		return new cl(args[0],args[1],args[2],args[3],args[4],args[5]);
	case 7:
		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
	case 8:
		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
	default:
		throw new js__$Boot_HaxeError("Too many arguments");
	}
	return null;
};
var _$UInt_UInt_$Impl_$ = {};
$hxClasses["_UInt.UInt_Impl_"] = _$UInt_UInt_$Impl_$;
_$UInt_UInt_$Impl_$.__name__ = ["_UInt","UInt_Impl_"];
_$UInt_UInt_$Impl_$.gt = function(a,b) {
	var aNeg = a < 0;
	var bNeg = b < 0;
	if(aNeg != bNeg) return aNeg; else return a > b;
};
_$UInt_UInt_$Impl_$.gte = function(a,b) {
	var aNeg = a < 0;
	var bNeg = b < 0;
	if(aNeg != bNeg) return aNeg; else return a >= b;
};
_$UInt_UInt_$Impl_$.toFloat = function(this1) {
	var $int = this1;
	if($int < 0) return 4294967296.0 + $int; else return $int + 0.0;
};
var com_isartdigital_Main = function() {
	EventEmitter.call(this);
	var lOptions = { };
	lOptions.backgroundColor = 10066329;
	this.renderer = PIXI.autoDetectRenderer(_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_width()),_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_height()),lOptions);
	window.document.body.appendChild(this.renderer.view);
	this.stage = new PIXI.Container();
	var lConfig = new PIXI.loaders.Loader();
	lConfig.add("config.json");
	lConfig.once("complete",$bind(this,this.preloadAssets));
	lConfig.load();
};
$hxClasses["com.isartdigital.Main"] = com_isartdigital_Main;
com_isartdigital_Main.__name__ = ["com","isartdigital","Main"];
com_isartdigital_Main.main = function() {
	com_isartdigital_Main.getInstance();
};
com_isartdigital_Main.getInstance = function() {
	if(com_isartdigital_Main.instance == null) com_isartdigital_Main.instance = new com_isartdigital_Main();
	return com_isartdigital_Main.instance;
};
com_isartdigital_Main.__super__ = EventEmitter;
com_isartdigital_Main.prototype = $extend(EventEmitter.prototype,{
	preloadAssets: function(pLoader) {
		com_isartdigital_utils_Config.init(Reflect.field(pLoader.resources,"config.json").data);
		if(com_isartdigital_utils_Config.get_debug()) com_isartdigital_utils_Debug.getInstance().init();
		if(com_isartdigital_utils_Config.get_debug() && com_isartdigital_utils_Config.get_data().boxAlpha != null) com_isartdigital_utils_game_StateGraphic.boxAlpha = com_isartdigital_utils_Config.get_data().boxAlpha;
		if(com_isartdigital_utils_Config.get_debug() && com_isartdigital_utils_Config.get_data().animAlpha != null) com_isartdigital_utils_game_StateGraphic.animAlpha = com_isartdigital_utils_Config.get_data().animAlpha;
		com_isartdigital_utils_game_GameStage.getInstance().set_scaleMode(com_isartdigital_utils_game_GameStageScale.SHOW_ALL);
		com_isartdigital_utils_game_GameStage.getInstance().init($bind(this,this.render),2048,1366,true);
		com_isartdigital_utils_system_DeviceCapabilities.displayFullScreenButton();
		this.stage.addChild(com_isartdigital_utils_game_GameStage.getInstance());
		window.addEventListener("resize",$bind(this,this.resize));
		this.resize();
		var lLoader = new com_isartdigital_utils_loader_GameLoader();
		lLoader.addAssetFile("black_bg.png");
		lLoader.addAssetFile("preload.png");
		lLoader.addAssetFile("preload_bg.png");
		lLoader.once("complete",$bind(this,this.loadAssets));
		lLoader.load();
	}
	,loadAssets: function(pLoader) {
		var lLoader = new com_isartdigital_utils_loader_GameLoader();
		lLoader.addTxtFile("boxes.json");
		lLoader.addSoundFile("sounds.json");
		lLoader.addAssetFile("alpha_bg.png");
		lLoader.addAssetFile("TitleCard_bg.png");
		lLoader.addAssetFile("background_decor.png");
		lLoader.addAssetFile("Confirm.png");
		lLoader.addAssetFile("Popin_Annonce.png");
		lLoader.addAssetFile("Scoring.png");
		lLoader.addAssetFile("Help.png");
		lLoader.addAssetFile("Credits.png");
		lLoader.addAssetFile("vase.png");
		lLoader.addAssetFile("symbales.png");
		lLoader.addAssetFile("riz.png");
		lLoader.addAssetFile("pinceau.png");
		lLoader.addAssetFile("percussions.png");
		lLoader.addAssetFile("masque.png");
		lLoader.addAssetFile("lanterne.png");
		lLoader.addAssetFile("homard.png");
		lLoader.addAssetFile("grue.png");
		lLoader.addAssetFile("eventail.png");
		lLoader.addAssetFile("choux.png");
		lLoader.addAssetFile("canardlaque.png");
		lLoader.addAssetFile("bouteille.png");
		lLoader.addAssetFile("lapin.png");
		lLoader.addAssetFile("stele.png");
		lLoader.addAssetFile("Inputzone.json");
		lLoader.addAssetFile("Template.json");
		lLoader.addAssetFile("Arrow.json");
		lLoader.addAssetFile("PlayButton.json");
		lLoader.addAssetFile("CreditButton.json");
		lLoader.addAssetFile("HelpButton.json");
		lLoader.addAssetFile("BackButton.json");
		lLoader.addAssetFile("Score.json");
		lLoader.addAssetFile("Timer.json");
		lLoader.addAssetFile("Player.json");
		lLoader.addAssetFile("BackgroundGame.json");
		lLoader.addAssetFile("Foule.json");
		lLoader.addAssetFile("CheckItem.json");
		lLoader.addAssetFile("animation_titlecard.json");
		lLoader.addFontFile("fonts.css");
		lLoader.on("progress",$bind(this,this.onLoadProgress));
		lLoader.once("complete",$bind(this,this.onLoadComplete));
		com_isartdigital_ui_UIManager.getInstance().openScreen(com_isartdigital_ui_GraphicLoader.getInstance());
		window.requestAnimationFrame($bind(this,this.gameLoop));
		lLoader.load();
	}
	,onLoadProgress: function(pLoader) {
		com_isartdigital_ui_GraphicLoader.getInstance().update(pLoader.progress / 100);
	}
	,onLoadComplete: function(pLoader) {
		pLoader.off("progress",$bind(this,this.onLoadProgress));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Template.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Arrow.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Inputzone.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("PlayButton.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("CreditButton.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("HelpButton.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("BackButton.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Score.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Timer.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Player.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("BackgroundGame.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("Foule.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("CheckItem.json"));
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures(com_isartdigital_utils_loader_GameLoader.getContent("animation_titlecard.json"));
		com_isartdigital_utils_game_StateGraphic.addBoxes(com_isartdigital_utils_loader_GameLoader.getContent("boxes.json"));
		com_isartdigital_ui_UIManager.getInstance().openScreen(com_isartdigital_ui_screens_TitleCard.getInstance());
	}
	,gameLoop: function() {
		window.requestAnimationFrame($bind(this,this.gameLoop));
		this.render();
		this.emit("gameLoop");
	}
	,resize: function(pEvent) {
		this.renderer.resize(_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_width()),_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_height()));
		com_isartdigital_utils_game_GameStage.getInstance().resize();
	}
	,render: function() {
		this.renderer.render(this.stage);
	}
	,destroy: function() {
		window.removeEventListener("resize",$bind(this,this.resize));
		com_isartdigital_Main.instance = null;
	}
	,__class__: com_isartdigital_Main
});
var com_isartdigital_game_Controller = function() {
	this.isPressed = false;
	this.lastInputDown = false;
	this.lastInputUp = false;
	this.lastInputRight = false;
	this.lastInputLeft = false;
	this.precInput = false;
	this.input = false;
	window.addEventListener("keydown",$bind(this,this.registerKeyDown));
	window.addEventListener("keyup",$bind(this,this.registerKeyUp));
};
$hxClasses["com.isartdigital.game.Controller"] = com_isartdigital_game_Controller;
com_isartdigital_game_Controller.__name__ = ["com","isartdigital","game","Controller"];
com_isartdigital_game_Controller.getInstance = function() {
	if(com_isartdigital_game_Controller.instance == null) com_isartdigital_game_Controller.instance = new com_isartdigital_game_Controller();
	return com_isartdigital_game_Controller.instance;
};
com_isartdigital_game_Controller.prototype = {
	destroy: function() {
		window.removeEventListener("keydown",$bind(this,this.registerKeyDown));
		window.removeEventListener("keyup",$bind(this,this.registerKeyUp));
		com_isartdigital_game_Controller.instance = null;
	}
	,registerKeyDown: function(pEvent) {
		if(!this.isPressed) {
			if(pEvent.keyCode == 37) this.left = true;
			if(pEvent.keyCode == 39) this.right = true;
			if(pEvent.keyCode == 40) this.down = true;
			if(pEvent.keyCode == 38) this.up = true;
			this.isPressed = true;
		} else {
			if(pEvent.keyCode == 37) this.left = false;
			if(pEvent.keyCode == 39) this.right = false;
			if(pEvent.keyCode == 40) this.down = false;
			if(pEvent.keyCode == 38) this.up = false;
		}
		if(pEvent.keyCode == 81) {
			this.Q = true;
			this.D = false;
		} else if(pEvent.keyCode == 68) {
			this.D = true;
			this.Q = false;
		}
	}
	,registerKeyUp: function(pEvent) {
		if(pEvent.keyCode == 37) this.left = false;
		if(pEvent.keyCode == 39) this.right = false;
		if(pEvent.keyCode == 40) this.down = false;
		if(pEvent.keyCode == 38) this.up = false;
		if(pEvent.keyCode == 81) this.Q = false;
		if(pEvent.keyCode == 68) this.D = false;
		this.isPressed = false;
	}
	,reset: function() {
		this.left = false;
		this.right = false;
		this.down = false;
		this.up = false;
	}
	,get_up: function() {
		return this.up;
	}
	,get_down: function() {
		return this.down;
	}
	,get_left: function() {
		return this.left;
	}
	,get_right: function() {
		return this.right;
	}
	,get_Q: function() {
		return this.Q;
	}
	,get_D: function() {
		return this.D;
	}
	,__class__: com_isartdigital_game_Controller
};
var com_isartdigital_game_GameManager = function() {
	this.currentSound = "MainloopCouche1";
	this.pause = false;
};
$hxClasses["com.isartdigital.game.GameManager"] = com_isartdigital_game_GameManager;
com_isartdigital_game_GameManager.__name__ = ["com","isartdigital","game","GameManager"];
com_isartdigital_game_GameManager.getInstance = function() {
	if(com_isartdigital_game_GameManager.instance == null) com_isartdigital_game_GameManager.instance = new com_isartdigital_game_GameManager();
	return com_isartdigital_game_GameManager.instance;
};
com_isartdigital_game_GameManager.prototype = {
	start: function() {
		com_isartdigital_ui_UIManager.getInstance().startGame();
		this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "background_decor.png"));
		com_isartdigital_utils_game_GameStage.getInstance().getDecorContainer().addChild(this.background);
		com_isartdigital_utils_game_GameStage.getInstance().getDecorContainer().addChild(com_isartdigital_game_sprites_BackgroundGame.getInstance());
		var lFoule = new com_isartdigital_game_sprites_Foule();
		com_isartdigital_utils_game_GameStage.getInstance().getDecorContainer().addChild(lFoule);
		lFoule.init();
		com_isartdigital_game_MoveManager.getInstance().init();
		com_isartdigital_game_Controller.getInstance();
		com_isartdigital_game_sprites_Player.getInstance().init();
		com_isartdigital_utils_game_GameStage.getInstance().getGameContainer().addChild(com_isartdigital_game_sprites_Player.getInstance());
		com_isartdigital_game_LevelManager.getInstance().apparitionTimer();
		this.createHUD();
		com_isartdigital_game_LevelManager.getInstance().setTimer();
		com_isartdigital_Main.getInstance().on("gameLoop",$bind(this,this.gameLoop));
		com_isartdigital_utils_sounds_SoundManager.getSound("MainloopCouche1").play();
		com_isartdigital_utils_sounds_SoundManager.getSound("MainloopCouche2").play().volume(0);
		com_isartdigital_utils_sounds_SoundManager.getSound("MainloopCouche3").play().volume(0);
	}
	,gameLoop: function(pEvent) {
		if(this.pause) return;
		com_isartdigital_game_MoveManager.doAction();
		com_isartdigital_game_sprites_Player.getInstance().doAction();
		com_isartdigital_game_sprites_Score.getInstance().doAction();
		com_isartdigital_game_sprites_BackgroundGame.getInstance().doAction();
		this.initAction(com_isartdigital_game_sprites_Arrow.arrowsArray);
		com_isartdigital_game_sprites_Foule.doActionManager();
		this.initAction(com_isartdigital_game_sprites_Foule.arrayFoule);
		this.initAction(com_isartdigital_game_sprites_CheckItem.arrayCheckItem);
		com_isartdigital_game_Controller.getInstance().reset();
	}
	,initAction: function(pArray) {
		var i = pArray.length - 1;
		while(i >= 0) {
			pArray[i].doAction();
			i--;
		}
	}
	,createHUD: function() {
		com_isartdigital_utils_game_GameStage.getInstance().addChild(com_isartdigital_game_sprites_Score.getInstance());
		com_isartdigital_utils_game_GameStage.getInstance().addChild(com_isartdigital_game_sprites_TimerHUD.getInstance());
	}
	,destroy: function() {
		com_isartdigital_Main.getInstance().off("gameLoop",$bind(this,this.gameLoop));
		com_isartdigital_game_GameManager.instance = null;
	}
	,__class__: com_isartdigital_game_GameManager
};
var com_isartdigital_game_LevelManager = function() {
	this.time = 45;
	this.currentObjects = [];
	this.otherObjects = [];
	this.toPickObjects = [];
	this.objects = ["vase","symbales","riz","pinceau","percussions","masque","lanterne","homard","grue","eventail","choux","canardlaque","bouteille","lapin","stele"];
	this.clearInterval = false;
};
$hxClasses["com.isartdigital.game.LevelManager"] = com_isartdigital_game_LevelManager;
com_isartdigital_game_LevelManager.__name__ = ["com","isartdigital","game","LevelManager"];
com_isartdigital_game_LevelManager.getInstance = function() {
	if(com_isartdigital_game_LevelManager.instance == null) com_isartdigital_game_LevelManager.instance = new com_isartdigital_game_LevelManager();
	return com_isartdigital_game_LevelManager.instance;
};
com_isartdigital_game_LevelManager.prototype = {
	setTimer: function() {
		var _g = this;
		haxe_Timer.delay(function() {
			_g.time--;
			com_isartdigital_game_sprites_TimerHUD.getInstance().setTimer(_g.time);
			if(_g.time != 0) _g.setTimer(); else {
				com_isartdigital_ui_UIManager.getInstance().openPopin(com_isartdigital_ui_popin_WinPopin.getInstance());
				_g.clearInterval = true;
			}
		},1000);
	}
	,apparitionTimer: function() {
		var _g = this;
		haxe_Timer.delay(function() {
			var _this = _g.pickObjects();
			_g.currentObjects = _this.slice();
			if(_g.clearInterval) return;
			_g.spawnObjects();
			_g.apparitionTimer();
		},Math.round(Math.random() * 5000 + 4000));
	}
	,toBePicked: function(pString) {
		var lIsRight = HxOverrides.indexOf(this.toPickObjects,pString,0) != -1;
		var lScreen = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance());
		var lCheck;
		if(pString != null) {
			if(lIsRight) {
				com_isartdigital_game_sprites_Score.getInstance().actualScore += 500;
				lCheck = new com_isartdigital_game_sprites_CheckItem(true);
				if(Math.random() < 0.5) com_isartdigital_utils_sounds_SoundManager.getSound("Yes").play(); else com_isartdigital_utils_sounds_SoundManager.getSound("Ouiii").play();
			} else {
				lCheck = new com_isartdigital_game_sprites_CheckItem(false);
				if(Math.random() < 0.5) com_isartdigital_utils_sounds_SoundManager.getSound("Nooo").play(); else com_isartdigital_utils_sounds_SoundManager.getSound("Ooow").play();
				if(com_isartdigital_game_GameManager.getInstance().currentSound == "MainloopCouche2") {
					com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(1,0,1000);
					com_isartdigital_game_GameManager.getInstance().currentSound = "MainloopCouche1";
					com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(0,1,1000);
				} else if(com_isartdigital_game_GameManager.getInstance().currentSound == "MainloopCouche3") {
					com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(1,0,1000);
					com_isartdigital_game_GameManager.getInstance().currentSound = "MainloopCouche2";
					com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(0,1,1000);
				}
				if(_$UInt_UInt_$Impl_$.gt(com_isartdigital_game_GameManager.levelLayer,0)) {
					com_isartdigital_game_GameManager.levelLayer--;
					return lIsRight;
				}
			}
			if(pString == this.currentObjects[0]) lCheck.position.set(lScreen.x + lScreen.width / 3,lScreen.y + lScreen.height / 3); else if(pString == this.currentObjects[1]) lCheck.position.set(lScreen.x + lScreen.width * 2 / 3,lScreen.y + lScreen.height / 3); else {
				lCheck.position.set(lScreen.x + lScreen.width * 0.5,lScreen.y + lScreen.height / 4.2);
				lCheck.scale = new PIXI.Point(0.4,0.4);
			}
			com_isartdigital_utils_game_GameStage.getInstance().addChild(lCheck);
			return lIsRight;
		} else {
			if(_$UInt_UInt_$Impl_$.gt(com_isartdigital_game_GameManager.levelLayer,0)) com_isartdigital_game_GameManager.levelLayer--;
			return lIsRight;
		}
	}
	,spawnObjects: function() {
		var _g = this;
		var lScreen = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance());
		var obj_1 = new PIXI.Sprite(PIXI.Texture.fromImage("/assets/" + this.currentObjects[0] + ".png"));
		var obj_2 = new PIXI.Sprite(PIXI.Texture.fromImage("/assets/" + this.currentObjects[1] + ".png"));
		var bulle_1 = new PIXI.Sprite(PIXI.Texture.fromImage("/assets/Bulle_objetgauche.png"));
		var bulle_2 = new PIXI.Sprite(PIXI.Texture.fromImage("/assets/Bulle_objetdroit.png"));
		obj_1.anchor.set(0.5,0.5);
		obj_2.anchor.set(0.5,0.5);
		bulle_1.anchor.set(0.5,0.5);
		bulle_2.anchor.set(0.5,0.5);
		com_isartdigital_utils_game_GameStage.getInstance().addChild(bulle_1);
		com_isartdigital_utils_game_GameStage.getInstance().addChild(bulle_2);
		com_isartdigital_utils_game_GameStage.getInstance().addChild(obj_1);
		com_isartdigital_utils_game_GameStage.getInstance().addChild(obj_2);
		obj_1.position.set(lScreen.x + lScreen.width / 3,lScreen.y + lScreen.height / 3);
		obj_2.position.set(lScreen.x + lScreen.width * 2 / 3,lScreen.y + lScreen.height / 3);
		bulle_1.position.set(lScreen.x + lScreen.width / 2.9,lScreen.y + lScreen.height / 2.9);
		bulle_2.position.set(lScreen.x + lScreen.width * 2 / 2.95,lScreen.y + lScreen.height / 2.9);
		obj_1.scale = new PIXI.Point(0.4,0.4);
		obj_2.scale = new PIXI.Point(0.4,0.4);
		bulle_1.scale = new PIXI.Point(0.5,0.5);
		bulle_2.scale = new PIXI.Point(0.5,0.5);
		haxe_Timer.delay(function() {
			obj_1.parent.removeChild(obj_1);
			obj_2.parent.removeChild(obj_2);
			obj_1.destroy();
			obj_2.destroy();
			bulle_1.parent.removeChild(bulle_1);
			bulle_2.parent.removeChild(bulle_2);
			bulle_1.destroy();
			bulle_2.destroy();
			if(_g.clearInterval) return;
			_g.toBePicked(_g.lootObject());
		},3000);
	}
	,lootObject: function() {
		var lootedObject;
		if(com_isartdigital_game_sprites_Player.getInstance().leftState) lootedObject = this.currentObjects[0]; else if(com_isartdigital_game_sprites_Player.getInstance().rightState) lootedObject = this.currentObjects[1]; else lootedObject = "";
		return lootedObject;
	}
	,setObjects: function() {
		var lObjects = this.objects.slice();
		var currentIndex;
		var _g = 0;
		while(_g < 3) {
			var i = _g++;
			currentIndex = Math.floor(Math.random() * lObjects.length);
			this.toPickObjects.push(lObjects[currentIndex]);
			lObjects.splice(currentIndex,1);
		}
		this.otherObjects = lObjects.slice();
	}
	,randValue: function(pArray) {
		return pArray[Math.floor(Math.random() * pArray.length)];
	}
	,pickObjects: function() {
		var lArray = [];
		lArray.push(this.randValue(this.toPickObjects));
		if(Math.random() > 0.5) lArray.unshift(this.randValue(this.otherObjects)); else lArray.push(this.randValue(this.otherObjects));
		return lArray;
	}
	,destroy: function() {
		com_isartdigital_game_LevelManager.instance = null;
	}
	,__class__: com_isartdigital_game_LevelManager
};
var com_isartdigital_game_MoveManager = function() {
	com_isartdigital_utils_game_GameStage.getInstance().addChild(com_isartdigital_game_sprites_InputZone.getInstance());
	com_isartdigital_game_sprites_InputZone.getInstance().init();
};
$hxClasses["com.isartdigital.game.MoveManager"] = com_isartdigital_game_MoveManager;
com_isartdigital_game_MoveManager.__name__ = ["com","isartdigital","game","MoveManager"];
com_isartdigital_game_MoveManager.getInstance = function() {
	if(com_isartdigital_game_MoveManager.instance == null) com_isartdigital_game_MoveManager.instance = new com_isartdigital_game_MoveManager();
	return com_isartdigital_game_MoveManager.instance;
};
com_isartdigital_game_MoveManager.doAction = function() {
	if(com_isartdigital_game_MoveManager.arrayArrow.length < 9 && com_isartdigital_game_MoveManager.createArrow) {
		var lArrow = new com_isartdigital_game_sprites_Arrow(com_isartdigital_game_MoveManager.arrayDirection[Math.ceil(Math.random() * com_isartdigital_game_MoveManager.arrayDirection.length - 1)]);
		lArrow.start();
		lArrow.init();
		lArrow.x = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance()).width + lArrow.width;
		lArrow.y = lArrow.height / 1.5;
		com_isartdigital_game_MoveManager.arrayArrow.push(lArrow);
		com_isartdigital_game_MoveManager.createArrow = false;
		com_isartdigital_utils_game_GameStage.getInstance().addChild(lArrow);
		haxe_Timer.delay(function() {
			com_isartdigital_game_MoveManager.createArrow = true;
		},1000);
	}
	var _g1 = 0;
	var _g = com_isartdigital_game_MoveManager.arrayArrow.length;
	while(_g1 < _g) {
		var i = _g1++;
		if(com_isartdigital_utils_game_CollisionManager.hitTestObject(com_isartdigital_game_MoveManager.arrayArrow[i].get_hitBox(),com_isartdigital_game_sprites_InputZone.getInstance().get_hitBox())) {
			if(com_isartdigital_game_Controller.getInstance().get_down() && com_isartdigital_game_MoveManager.getArrowName("Down",i)) {
				com_isartdigital_game_sprites_Player.getInstance().setModeDown();
				com_isartdigital_game_MoveManager.valideArrow(i);
				com_isartdigital_game_MoveManager.checkFxArrow("Couche12flèche1","Couche3flèchebas");
			}
			if(com_isartdigital_game_Controller.getInstance().get_up() && com_isartdigital_game_MoveManager.getArrowName("Up",i)) {
				com_isartdigital_game_MoveManager.valideArrow(i);
				com_isartdigital_game_sprites_Player.getInstance().setModeUp();
				com_isartdigital_game_MoveManager.checkFxArrow("Couche12flèche2","Couche3flèchehaut");
			}
			if(com_isartdigital_game_Controller.getInstance().get_left() && com_isartdigital_game_MoveManager.getArrowName("Left",i)) {
				com_isartdigital_game_MoveManager.valideArrow(i);
				com_isartdigital_game_sprites_Player.getInstance().setModeLeft();
				com_isartdigital_game_MoveManager.checkFxArrow("Couche12flèche3","Couche3flèchegauche");
			}
			if(com_isartdigital_game_Controller.getInstance().get_right() && com_isartdigital_game_MoveManager.getArrowName("Right",i)) {
				com_isartdigital_game_MoveManager.valideArrow(i);
				com_isartdigital_game_sprites_Player.getInstance().setModeRight();
				com_isartdigital_game_MoveManager.checkFxArrow("Couche12flèche4","Couche3flèchedroite");
			}
		}
	}
};
com_isartdigital_game_MoveManager.checkFxArrow = function(pSon_1,pSon_2) {
	if(com_isartdigital_game_GameManager.levelLayer != 2) com_isartdigital_utils_sounds_SoundManager.getSound(pSon_1).play(); else com_isartdigital_utils_sounds_SoundManager.getSound(pSon_2).play();
};
com_isartdigital_game_MoveManager.valideArrow = function(i) {
	com_isartdigital_game_MoveManager.arrayArrow[i].alpha = 0;
	com_isartdigital_game_sprites_Score.getInstance().actualScore += 100;
	com_isartdigital_game_MoveManager.combo++;
	if(com_isartdigital_game_MoveManager.combo == 8) {
		if(_$UInt_UInt_$Impl_$.gt(2,com_isartdigital_game_GameManager.levelLayer)) com_isartdigital_game_GameManager.levelLayer++;
		if(com_isartdigital_game_GameManager.getInstance().currentSound == "MainloopCouche1") {
			com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(1,0,1000);
			com_isartdigital_game_GameManager.getInstance().currentSound = "MainloopCouche2";
			com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(0,1,1000);
		} else if(com_isartdigital_game_GameManager.getInstance().currentSound == "MainloopCouche2") {
			com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(1,0,1000);
			com_isartdigital_game_GameManager.getInstance().currentSound = "MainloopCouche3";
			com_isartdigital_utils_sounds_SoundManager.getSound(com_isartdigital_game_GameManager.getInstance().currentSound).fade(0,1,1000);
		}
		com_isartdigital_game_MoveManager.combo = 0;
	}
};
com_isartdigital_game_MoveManager.getArrowName = function(pName,i) {
	return com_isartdigital_game_MoveManager.arrayArrow[i].getAssetName().substring(0,com_isartdigital_game_MoveManager.arrayArrow[i].getAssetName().indexOf("Arrow")) == pName;
};
com_isartdigital_game_MoveManager.prototype = {
	init: function() {
		com_isartdigital_game_MoveManager.arrayDirection.push("Left");
		com_isartdigital_game_MoveManager.arrayDirection.push("Right");
		com_isartdigital_game_MoveManager.arrayDirection.push("Up");
		com_isartdigital_game_MoveManager.arrayDirection.push("Down");
	}
	,destroy: function() {
		com_isartdigital_game_MoveManager.instance = null;
	}
	,__class__: com_isartdigital_game_MoveManager
};
var com_isartdigital_utils_game_GameObject = function() {
	PIXI.Container.call(this);
	this.on("added",$bind(this,this.forceUpdateTransform));
};
$hxClasses["com.isartdigital.utils.game.GameObject"] = com_isartdigital_utils_game_GameObject;
com_isartdigital_utils_game_GameObject.__name__ = ["com","isartdigital","utils","game","GameObject"];
com_isartdigital_utils_game_GameObject.__super__ = PIXI.Container;
com_isartdigital_utils_game_GameObject.prototype = $extend(PIXI.Container.prototype,{
	forceUpdateTransform: function() {
		this.updateTransform();
	}
	,destroy: function() {
		this.off("added",$bind(this,this.forceUpdateTransform));
		PIXI.Container.prototype.destroy.call(this,true);
	}
	,__class__: com_isartdigital_utils_game_GameObject
});
var com_isartdigital_utils_game_IStateMachine = function() { };
$hxClasses["com.isartdigital.utils.game.IStateMachine"] = com_isartdigital_utils_game_IStateMachine;
com_isartdigital_utils_game_IStateMachine.__name__ = ["com","isartdigital","utils","game","IStateMachine"];
com_isartdigital_utils_game_IStateMachine.prototype = {
	__class__: com_isartdigital_utils_game_IStateMachine
};
var com_isartdigital_utils_game_StateMachine = function() {
	com_isartdigital_utils_game_GameObject.call(this);
	this.setModeVoid();
};
$hxClasses["com.isartdigital.utils.game.StateMachine"] = com_isartdigital_utils_game_StateMachine;
com_isartdigital_utils_game_StateMachine.__name__ = ["com","isartdigital","utils","game","StateMachine"];
com_isartdigital_utils_game_StateMachine.__interfaces__ = [com_isartdigital_utils_game_IStateMachine];
com_isartdigital_utils_game_StateMachine.__super__ = com_isartdigital_utils_game_GameObject;
com_isartdigital_utils_game_StateMachine.prototype = $extend(com_isartdigital_utils_game_GameObject.prototype,{
	setModeVoid: function() {
		this.doAction = $bind(this,this.doActionVoid);
	}
	,doActionVoid: function() {
	}
	,setModeNormal: function() {
		this.doAction = $bind(this,this.doActionNormal);
	}
	,doActionNormal: function() {
	}
	,start: function() {
		this.setModeNormal();
	}
	,destroy: function() {
		this.setModeVoid();
		com_isartdigital_utils_game_GameObject.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_utils_game_StateMachine
});
var com_isartdigital_utils_game_StateGraphic = function() {
	this.boxType = com_isartdigital_utils_game_BoxType.NONE;
	this.DEFAULT_STATE = "";
	this.BOX_SUFFIX = "box";
	this.ANIM_SUFFIX = "";
	com_isartdigital_utils_game_StateMachine.call(this);
};
$hxClasses["com.isartdigital.utils.game.StateGraphic"] = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_utils_game_StateGraphic.__name__ = ["com","isartdigital","utils","game","StateGraphic"];
com_isartdigital_utils_game_StateGraphic.addBoxes = function(pJson) {
	if(com_isartdigital_utils_game_StateGraphic.boxesCache == null) com_isartdigital_utils_game_StateGraphic.boxesCache = new haxe_ds_StringMap();
	var lItem;
	var lObj;
	var _g = 0;
	var _g1 = Reflect.fields(pJson);
	while(_g < _g1.length) {
		var lName = _g1[_g];
		++_g;
		lItem = Reflect.field(pJson,lName);
		var v = new haxe_ds_StringMap();
		com_isartdigital_utils_game_StateGraphic.boxesCache.set(lName,v);
		v;
		var _g2 = 0;
		var _g3 = Reflect.fields(lItem);
		while(_g2 < _g3.length) {
			var lObjName = _g3[_g2];
			++_g2;
			lObj = Reflect.field(lItem,lObjName);
			if(lObj.type == "Rectangle") {
				var this1 = com_isartdigital_utils_game_StateGraphic.boxesCache.get(lName);
				var v1 = new PIXI.Rectangle(lObj.x,lObj.y,lObj.width,lObj.height);
				this1.set(lObjName,v1);
				v1;
			} else if(lObj.type == "Ellipse") {
				var this2 = com_isartdigital_utils_game_StateGraphic.boxesCache.get(lName);
				var v2 = new PIXI.Ellipse(lObj.x,lObj.y,lObj.width / 2,lObj.height / 2);
				this2.set(lObjName,v2);
				v2;
			} else if(lObj.type == "Circle") {
				var this3 = com_isartdigital_utils_game_StateGraphic.boxesCache.get(lName);
				var v3 = new PIXI.Circle(lObj.x,lObj.y,lObj.radius);
				this3.set(lObjName,v3);
				v3;
			} else if(lObj.type == "Point") {
				var this4 = com_isartdigital_utils_game_StateGraphic.boxesCache.get(lName);
				var v4 = new PIXI.Point(lObj.x,lObj.y);
				this4.set(lObjName,v4);
				v4;
			}
		}
	}
};
com_isartdigital_utils_game_StateGraphic.__super__ = com_isartdigital_utils_game_StateMachine;
com_isartdigital_utils_game_StateGraphic.prototype = $extend(com_isartdigital_utils_game_StateMachine.prototype,{
	setAnimEnd: function() {
		this.isAnimEnd = true;
	}
	,setState: function(pState,pLoop,pAutoPlay,pStart) {
		if(pStart == null) pStart = 0;
		if(pAutoPlay == null) pAutoPlay = true;
		if(pLoop == null) pLoop = false;
		var lClassName = Type.getClassName(js_Boot.getClass(this));
		if(this.factory == null) throw new js__$Boot_HaxeError(lClassName + " :: propriété factory non définie");
		if(this.state == pState) return;
		if(this.assetName == null) this.assetName = lClassName.split(".").pop();
		this.state = pState;
		this.anim = this.factory.getAnim();
		if(this.anim == null) {
			if(this.boxType == com_isartdigital_utils_game_BoxType.SELF) {
				if(this.box != null) this.removeChild(this.box);
				this.box = null;
			}
			this.anim = this.factory.create(this.getID(this.state));
			this.anim.scale.set(1 / com_isartdigital_utils_system_DeviceCapabilities.textureRatio,1 / com_isartdigital_utils_system_DeviceCapabilities.textureRatio);
			if(com_isartdigital_utils_game_StateGraphic.animAlpha < 1) this.anim.alpha = com_isartdigital_utils_game_StateGraphic.animAlpha;
			this.addChild(this.anim);
		} else this.factory.update(this.getID(this.state));
		this.isAnimEnd = false;
		this.anim.loop = pLoop;
		this.factory.setFrame(pAutoPlay,pStart);
		if(this.box == null) {
			if(this.boxType == com_isartdigital_utils_game_BoxType.SELF) {
				this.box = this.anim;
				return;
			} else {
				this.box = new PIXI.Container();
				if(this.boxType != com_isartdigital_utils_game_BoxType.NONE) this.createBox();
			}
			this.addChild(this.box);
		} else if(this.boxType == com_isartdigital_utils_game_BoxType.MULTIPLE) {
			this.removeChild(this.box);
			this.box = new PIXI.Container();
			this.createBox();
			this.addChild(this.box);
		}
	}
	,getID: function(pState) {
		if(pState == this.DEFAULT_STATE) return this.assetName + this.ANIM_SUFFIX;
		return this.assetName + "_" + pState + this.ANIM_SUFFIX;
	}
	,createBox: function() {
		var lBoxes = this.getBox((this.boxType == com_isartdigital_utils_game_BoxType.MULTIPLE?this.state + "_":"") + this.BOX_SUFFIX);
		var lChild;
		var $it0 = lBoxes.keys();
		while( $it0.hasNext() ) {
			var lBox = $it0.next();
			lChild = new PIXI.Graphics();
			lChild.beginFill(16720418);
			if(Std["is"](__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox],PIXI.Rectangle)) lChild.drawRect((__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).x,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).y,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).width,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).height); else if(Std["is"](__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox],PIXI.Ellipse)) lChild.drawEllipse((__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).x,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).y,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).width,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).height); else if(Std["is"](__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox],PIXI.Circle)) lChild.drawCircle((__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).x,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).y,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).radius); else if(Std["is"](__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox],PIXI.Point)) lChild.drawCircle(0,0,10);
			lChild.endFill();
			lChild.name = lBox;
			if(Std["is"](__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox],PIXI.Point)) lChild.position.set((__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).x,(__map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox]).y); else lChild.hitArea = __map_reserved[lBox] != null?lBoxes.getReserved(lBox):lBoxes.h[lBox];
			this.box.addChild(lChild);
		}
		if(com_isartdigital_utils_game_StateGraphic.boxAlpha == 0) this.box.renderable = false; else this.box.alpha = com_isartdigital_utils_game_StateGraphic.boxAlpha;
	}
	,getBox: function(pState) {
		return com_isartdigital_utils_game_StateGraphic.boxesCache.get(this.assetName + "_" + pState);
	}
	,pause: function() {
		if(this.anim != null) this.anim.stop();
	}
	,resume: function() {
		if(this.anim != null) this.anim.play();
	}
	,get_hitBox: function() {
		return this.box;
	}
	,get_hitPoints: function() {
		return null;
	}
	,destroy: function() {
		this.anim.stop();
		this.removeChild(this.anim);
		this.anim.destroy();
		this.anim = null;
		this.removeChild(this.box);
		this.box.destroy();
		this.box = null;
		com_isartdigital_utils_game_StateMachine.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_utils_game_StateGraphic
});
var com_isartdigital_game_sprites_Animation_$titlecard = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
	this.init();
};
$hxClasses["com.isartdigital.game.sprites.Animation_titlecard"] = com_isartdigital_game_sprites_Animation_$titlecard;
com_isartdigital_game_sprites_Animation_$titlecard.__name__ = ["com","isartdigital","game","sprites","Animation_titlecard"];
com_isartdigital_game_sprites_Animation_$titlecard.getInstance = function() {
	if(com_isartdigital_game_sprites_Animation_$titlecard.instance == null) com_isartdigital_game_sprites_Animation_$titlecard.instance = new com_isartdigital_game_sprites_Animation_$titlecard();
	return com_isartdigital_game_sprites_Animation_$titlecard.instance;
};
com_isartdigital_game_sprites_Animation_$titlecard.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Animation_$titlecard.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setModeNormal();
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		this.anim.scale.set(0.7,0.7);
		this.anim.animationSpeed = 0.15;
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,destroy: function() {
		com_isartdigital_game_sprites_Animation_$titlecard.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_Animation_$titlecard
});
var com_isartdigital_game_sprites_Arrow = function(pString) {
	this.currentSpeed = 0;
	if(!com_isartdigital_game_sprites_Arrow.firstArrow) {
		com_isartdigital_game_sprites_Arrow.firstArrow = true;
		return;
	}
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
	this.assetName = pString + "Arrow";
	com_isartdigital_game_sprites_Arrow.arrowsArray.push(this);
	this.currentSpeed = com_isartdigital_game_sprites_Arrow.speeds[com_isartdigital_game_GameManager.levelLayer];
};
$hxClasses["com.isartdigital.game.sprites.Arrow"] = com_isartdigital_game_sprites_Arrow;
com_isartdigital_game_sprites_Arrow.__name__ = ["com","isartdigital","game","sprites","Arrow"];
com_isartdigital_game_sprites_Arrow.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Arrow.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.setModeNormal();
	}
	,setPosition: function(pGlobal) {
		var lLocal = this.parent.toLocal(pGlobal);
		this.position.set(lLocal.x,lLocal.y);
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,doActionNormal: function() {
		this.currentSpeed = com_isartdigital_game_sprites_Arrow.speeds[com_isartdigital_game_GameManager.levelLayer];
		this.x -= this.currentSpeed;
		if(this.x < com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance()).x + com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance()).width / 4) this.alpha = 0.2;
		if(this.x < com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance()).x - this.width) {
			this.remove();
			com_isartdigital_game_sprites_Arrow.arrowsArray.slice(HxOverrides.indexOf(com_isartdigital_game_sprites_Arrow.arrowsArray,this,0));
			if(HxOverrides.indexOf(com_isartdigital_game_MoveManager.arrayArrow,this,0) != -1) com_isartdigital_game_MoveManager.arrayArrow.splice(HxOverrides.indexOf(com_isartdigital_game_MoveManager.arrayArrow,this,0),1);
			this.destroy();
			return;
		}
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
	}
	,getAssetName: function() {
		return this.assetName;
	}
	,remove: function() {
		this.parent.removeChild(this);
		this.destroy();
	}
	,__class__: com_isartdigital_game_sprites_Arrow
});
var com_isartdigital_game_sprites_BackgroundGame = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
	this.init();
};
$hxClasses["com.isartdigital.game.sprites.BackgroundGame"] = com_isartdigital_game_sprites_BackgroundGame;
com_isartdigital_game_sprites_BackgroundGame.__name__ = ["com","isartdigital","game","sprites","BackgroundGame"];
com_isartdigital_game_sprites_BackgroundGame.getInstance = function() {
	if(com_isartdigital_game_sprites_BackgroundGame.instance == null) com_isartdigital_game_sprites_BackgroundGame.instance = new com_isartdigital_game_sprites_BackgroundGame();
	return com_isartdigital_game_sprites_BackgroundGame.instance;
};
com_isartdigital_game_sprites_BackgroundGame.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_BackgroundGame.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setModeNormal();
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		this.anim.animationSpeed = 0.15;
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,destroy: function() {
		com_isartdigital_game_sprites_BackgroundGame.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_BackgroundGame
});
var com_isartdigital_game_sprites_CheckItem = function(pBool) {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
	this.init(pBool);
	this.anim.animationSpeed = 0.1;
	com_isartdigital_game_sprites_CheckItem.arrayCheckItem.push(this);
};
$hxClasses["com.isartdigital.game.sprites.CheckItem"] = com_isartdigital_game_sprites_CheckItem;
com_isartdigital_game_sprites_CheckItem.__name__ = ["com","isartdigital","game","sprites","CheckItem"];
com_isartdigital_game_sprites_CheckItem.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_CheckItem.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function(pBool) {
		this.start();
		if(pBool) this.setModeCorrect(); else this.setModeWrong();
	}
	,setModeCorrect: function() {
		this.setState("right");
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
	}
	,setModeWrong: function() {
		this.setState("wrong");
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
	}
	,doActionNormal: function() {
		var _g = this;
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
		this.anim.onComplete = function() {
			_g.finished();
		};
	}
	,finished: function() {
		com_isartdigital_utils_game_GameStage.getInstance().removeChild(this);
		com_isartdigital_game_sprites_CheckItem.arrayCheckItem.splice(HxOverrides.indexOf(com_isartdigital_game_sprites_CheckItem.arrayCheckItem,this,0),1);
		this.destroy();
	}
	,__class__: com_isartdigital_game_sprites_CheckItem
});
var com_isartdigital_game_sprites_Foule = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
	com_isartdigital_game_sprites_Foule.arrayFoule.push(this);
};
$hxClasses["com.isartdigital.game.sprites.Foule"] = com_isartdigital_game_sprites_Foule;
com_isartdigital_game_sprites_Foule.__name__ = ["com","isartdigital","game","sprites","Foule"];
com_isartdigital_game_sprites_Foule.doActionManager = function() {
	if(com_isartdigital_game_sprites_Foule.nbFrame == 0) {
		var lFoule = new com_isartdigital_game_sprites_Foule();
		com_isartdigital_utils_game_GameStage.getInstance().getDecorContainer().addChild(lFoule);
		lFoule.init();
		com_isartdigital_game_sprites_Foule.nbFrame = 20;
	} else com_isartdigital_game_sprites_Foule.nbFrame = com_isartdigital_game_sprites_Foule.nbFrame - 1;
};
com_isartdigital_game_sprites_Foule.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Foule.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setModeNormal();
	}
	,doActionNormal: function() {
		var _g = this;
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
		this.anim.onComplete = function() {
			_g.finished();
		};
	}
	,finished: function() {
		com_isartdigital_game_sprites_Foule.arrayFoule.splice(HxOverrides.indexOf(com_isartdigital_game_sprites_Foule.arrayFoule,this,0),1);
		com_isartdigital_utils_game_GameStage.getInstance().getDecorContainer().removeChild(this);
		this.destroy();
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE);
		this.anim.animationSpeed = 0.15;
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,__class__: com_isartdigital_game_sprites_Foule
});
var com_isartdigital_game_sprites_InputZone = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.assetName = "Inputzone";
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
};
$hxClasses["com.isartdigital.game.sprites.InputZone"] = com_isartdigital_game_sprites_InputZone;
com_isartdigital_game_sprites_InputZone.__name__ = ["com","isartdigital","game","sprites","InputZone"];
com_isartdigital_game_sprites_InputZone.getInstance = function() {
	if(com_isartdigital_game_sprites_InputZone.instance == null) com_isartdigital_game_sprites_InputZone.instance = new com_isartdigital_game_sprites_InputZone();
	return com_isartdigital_game_sprites_InputZone.instance;
};
com_isartdigital_game_sprites_InputZone.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_InputZone.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setModeNormal();
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
		this.x = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance()).height / 3;
		this.y = this.anim.width / 2;
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,destroy: function() {
		com_isartdigital_game_sprites_InputZone.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_InputZone
});
var com_isartdigital_game_sprites_Player = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
};
$hxClasses["com.isartdigital.game.sprites.Player"] = com_isartdigital_game_sprites_Player;
com_isartdigital_game_sprites_Player.__name__ = ["com","isartdigital","game","sprites","Player"];
com_isartdigital_game_sprites_Player.getInstance = function() {
	if(com_isartdigital_game_sprites_Player.instance == null) com_isartdigital_game_sprites_Player.instance = new com_isartdigital_game_sprites_Player();
	return com_isartdigital_game_sprites_Player.instance;
};
com_isartdigital_game_sprites_Player.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Player.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.x = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance().getGameContainer()).x + com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance().getGameContainer()).width / 2;
		this.y = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance().getGameContainer()).y + com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance().getGameContainer()).height * 5 / 8;
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
	}
	,doActionMove: function() {
		var test = 0;
		var lScreen = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance().getGameContainer());
		if(com_isartdigital_game_Controller.getInstance().get_Q() || com_isartdigital_game_Controller.getInstance().get_D()) {
			if(com_isartdigital_game_Controller.getInstance().get_Q() && lScreen.x + lScreen.width * 7 / 16 < this.x) this.x -= com_isartdigital_game_sprites_Player.speed;
			if(com_isartdigital_game_Controller.getInstance().get_D() && lScreen.x + lScreen.width * 9 / 16 > this.x) this.x += com_isartdigital_game_sprites_Player.speed;
		} else {
			if(this.x + com_isartdigital_game_sprites_Player.speed >= lScreen.x + lScreen.width / 2 && this.x - com_isartdigital_game_sprites_Player.speed <= lScreen.x + lScreen.width / 2) return;
			if(lScreen.x + lScreen.width / 2 < this.x) this.x -= com_isartdigital_game_sprites_Player.speed; else this.x += com_isartdigital_game_sprites_Player.speed;
		}
		if(this.x < lScreen.x + lScreen.width * 7.5 / 16) {
			this.leftState = true;
			this.rightState = false;
		} else if(this.x > lScreen.x + lScreen.width * 8.5 / 16) {
			this.leftState = false;
			this.rightState = true;
		} else {
			this.leftState = false;
			this.rightState = false;
		}
	}
	,doActionNormal: function() {
		this.anim.animationSpeed = 0.18;
		this.doActionMove();
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
	}
	,setModeNormal: function() {
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
		this.setState(com_isartdigital_game_sprites_Player.IDLE_STATE,true);
	}
	,setModeUp: function() {
		this.setState(com_isartdigital_game_sprites_Player.UP_STATE);
		this.doAction = $bind(this,this.doActionUp);
	}
	,setModeDown: function() {
		this.setState(com_isartdigital_game_sprites_Player.DOWN_STATE);
		this.doAction = $bind(this,this.doActionDown);
	}
	,setModeLeft: function() {
		this.setState(com_isartdigital_game_sprites_Player.LEFT_STATE);
		this.doAction = $bind(this,this.doActionLeft);
	}
	,setModeRight: function() {
		this.setState(com_isartdigital_game_sprites_Player.RIGHT_STATE);
		this.doAction = $bind(this,this.doActionRight);
	}
	,doActionUp: function() {
		var _g = this;
		this.doActionMove();
		this.anim.onComplete = function() {
			_g.setModeNormal();
		};
	}
	,doActionDown: function() {
		var _g = this;
		this.doActionMove();
		this.anim.onComplete = function() {
			_g.setModeNormal();
		};
	}
	,doActionLeft: function() {
		var _g = this;
		this.doActionMove();
		this.anim.onComplete = function() {
			_g.setModeNormal();
		};
	}
	,doActionRight: function() {
		var _g = this;
		this.doActionMove();
		this.anim.onComplete = function() {
			_g.setModeNormal();
		};
	}
	,pickObject: function(index) {
		if(this.isAnimEnd) this.setModeNormal();
	}
	,destroy: function() {
		com_isartdigital_game_sprites_Player.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_Player
});
var com_isartdigital_game_sprites_Score = function() {
	this.txtStyle = { fill : "white", stroke : "black", strokeThickness : 5, font : "62px tao"};
	this.actualScore = 0;
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.assetName = "Score";
	this.init();
};
$hxClasses["com.isartdigital.game.sprites.Score"] = com_isartdigital_game_sprites_Score;
com_isartdigital_game_sprites_Score.__name__ = ["com","isartdigital","game","sprites","Score"];
com_isartdigital_game_sprites_Score.getInstance = function() {
	if(com_isartdigital_game_sprites_Score.instance == null) com_isartdigital_game_sprites_Score.instance = new com_isartdigital_game_sprites_Score();
	return com_isartdigital_game_sprites_Score.instance;
};
com_isartdigital_game_sprites_Score.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Score.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setScore();
		this.setModeNormal();
	}
	,doActionNormal: function() {
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
		this.txt.text = this.actualScore;
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
		this.position.set(com_isartdigital_game_sprites_InputZone.getInstance().x - this.anim.width,this.anim.height / 2);
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,setScore: function() {
		this.txt = new PIXI.Text(this.actualScore,this.txtStyle);
		this.txt.anchor.set(0.5,0.5);
		this.addChild(this.txt);
	}
	,destroy: function() {
		com_isartdigital_utils_game_StateGraphic.prototype.destroy.call(this);
		com_isartdigital_game_sprites_Score.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_Score
});
var com_isartdigital_game_sprites_Template = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.boxType = com_isartdigital_utils_game_BoxType.SIMPLE;
};
$hxClasses["com.isartdigital.game.sprites.Template"] = com_isartdigital_game_sprites_Template;
com_isartdigital_game_sprites_Template.__name__ = ["com","isartdigital","game","sprites","Template"];
com_isartdigital_game_sprites_Template.getInstance = function() {
	if(com_isartdigital_game_sprites_Template.instance == null) com_isartdigital_game_sprites_Template.instance = new com_isartdigital_game_sprites_Template();
	return com_isartdigital_game_sprites_Template.instance;
};
com_isartdigital_game_sprites_Template.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_Template.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,onTouch: function(pEvent) {
		if(!js_Boot.__instanceof(pEvent.target,HTMLCanvasElement)) return;
		this.setPosition(new PIXI.Point(pEvent.targetTouches[pEvent.targetTouches.length - 1].clientX,pEvent.targetTouches[pEvent.targetTouches.length - 1].clientY));
	}
	,onClick: function(pEvent) {
		if(!js_Boot.__instanceof(pEvent.target,HTMLCanvasElement)) return;
		this.setPosition(new PIXI.Point(pEvent.layerX,pEvent.layerY));
	}
	,setPosition: function(pGlobal) {
		var lLocal = this.parent.toLocal(pGlobal);
		this.position.set(lLocal.x,lLocal.y);
	}
	,destroy: function() {
		window.removeEventListener("click",$bind(this,this.onClick));
		window.removeEventListener("touchstart",$bind(this,this.onTouch));
		com_isartdigital_game_sprites_Template.instance = null;
		com_isartdigital_utils_game_StateGraphic.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_game_sprites_Template
});
var com_isartdigital_game_sprites_TimerHUD = function() {
	this.txtStyle = { fill : "white", stroke : "black", strokeThickness : 5, font : "62px tao"};
	this.actualTimer = 0;
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.assetName = "Timer";
	this.init();
};
$hxClasses["com.isartdigital.game.sprites.TimerHUD"] = com_isartdigital_game_sprites_TimerHUD;
com_isartdigital_game_sprites_TimerHUD.__name__ = ["com","isartdigital","game","sprites","TimerHUD"];
com_isartdigital_game_sprites_TimerHUD.getInstance = function() {
	if(com_isartdigital_game_sprites_TimerHUD.instance == null) com_isartdigital_game_sprites_TimerHUD.instance = new com_isartdigital_game_sprites_TimerHUD();
	return com_isartdigital_game_sprites_TimerHUD.instance;
};
com_isartdigital_game_sprites_TimerHUD.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_game_sprites_TimerHUD.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	init: function() {
		this.start();
		this.setTimer(120);
		this.setModeNormal();
	}
	,doActionNormal: function() {
		com_isartdigital_utils_game_StateGraphic.prototype.doActionNormal.call(this);
		this.txt.text = this.actualTimer;
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE,true);
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).anchor.set(0.5,0.5);
		this.position.set(com_isartdigital_game_sprites_Score.getInstance().x,com_isartdigital_game_sprites_Score.getInstance().y + this.anim.height);
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,setTimer: function(pTime) {
		if(this.txt != null) this.removeChild(this.txt);
		this.txt = new PIXI.Text(com_isartdigital_game_LevelManager.getInstance().time,this.txtStyle);
		this.txt.anchor.set(0.5,0.5);
		this.addChild(this.txt);
	}
	,destroy: function() {
		com_isartdigital_game_sprites_TimerHUD.instance = null;
	}
	,__class__: com_isartdigital_game_sprites_TimerHUD
});
var com_isartdigital_ui_CheatPanel = function() {
	this.init();
};
$hxClasses["com.isartdigital.ui.CheatPanel"] = com_isartdigital_ui_CheatPanel;
com_isartdigital_ui_CheatPanel.__name__ = ["com","isartdigital","ui","CheatPanel"];
com_isartdigital_ui_CheatPanel.getInstance = function() {
	if(com_isartdigital_ui_CheatPanel.instance == null) com_isartdigital_ui_CheatPanel.instance = new com_isartdigital_ui_CheatPanel();
	return com_isartdigital_ui_CheatPanel.instance;
};
com_isartdigital_ui_CheatPanel.prototype = {
	init: function() {
		if(com_isartdigital_utils_Config.get_debug() && com_isartdigital_utils_Config.get_data().cheat && !com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) this.gui = new dat.gui.GUI();
	}
	,ingame: function() {
		if(this.gui == null) return;
		this.gui.add(com_isartdigital_game_sprites_Template.getInstance(),"x",-1000,1000).listen();
		this.gui.add(com_isartdigital_game_sprites_Template.getInstance(),"y",-500,500).listen();
	}
	,clear: function() {
		if(this.gui == null) return;
		this.gui.destroy();
		this.init();
	}
	,destroy: function() {
		com_isartdigital_ui_CheatPanel.instance = null;
	}
	,__class__: com_isartdigital_ui_CheatPanel
};
var com_isartdigital_utils_ui_UIComponent = function() {
	this.modalImage = "assets/alpha_bg.png";
	this._modal = true;
	this.positionables = [];
	com_isartdigital_utils_game_GameObject.call(this);
};
$hxClasses["com.isartdigital.utils.ui.UIComponent"] = com_isartdigital_utils_ui_UIComponent;
com_isartdigital_utils_ui_UIComponent.__name__ = ["com","isartdigital","utils","ui","UIComponent"];
com_isartdigital_utils_ui_UIComponent.__super__ = com_isartdigital_utils_game_GameObject;
com_isartdigital_utils_ui_UIComponent.prototype = $extend(com_isartdigital_utils_game_GameObject.prototype,{
	build: function() {
		var lClassName = Type.getClassName(js_Boot.getClass(this));
		lClassName = lClassName.substring(lClassName.lastIndexOf(".") + 1);
		var lItems = com_isartdigital_utils_ui_UIBuilder.build(lClassName);
		var _g = 0;
		while(_g < lItems.length) {
			var lItem = lItems[_g];
			++_g;
			this.addChild(lItem.item);
			if(lItem.align != "") this.positionables.push(lItem);
		}
	}
	,open: function() {
		if(this.isOpened) return;
		this.isOpened = true;
		this.set_modal(this._modal);
		com_isartdigital_utils_game_GameStage.getInstance().on("resize",$bind(this,this.onResize));
		this.onResize();
	}
	,get_modal: function() {
		return this._modal;
	}
	,set_modal: function(pModal) {
		this._modal = pModal;
		if(this._modal) {
			if(this.modalZone == null) {
				this.modalZone = new PIXI.Sprite(PIXI.Texture.fromImage(this.modalImage));
				this.modalZone.interactive = true;
				this.modalZone.on("click",$bind(this,this.stopPropagation));
				this.modalZone.on("tap",$bind(this,this.stopPropagation));
				this.positionables.unshift({ item : this.modalZone, align : "fitScreen", offsetX : 0, offsetY : 0});
			}
			if(this.parent != null) this.parent.addChildAt(this.modalZone,this.parent.getChildIndex(this));
		} else if(this.modalZone != null) {
			if(this.modalZone.parent != null) this.modalZone.parent.removeChild(this.modalZone);
			this.modalZone.off("click",$bind(this,this.stopPropagation));
			this.modalZone.off("tap",$bind(this,this.stopPropagation));
			this.modalZone = null;
			if(this.positionables[0].item == this.modalZone) this.positionables.shift();
		}
		return this._modal;
	}
	,stopPropagation: function(pEvent) {
	}
	,close: function() {
		if(!this.isOpened) return;
		this.isOpened = false;
		this.set_modal(false);
		this.destroy();
	}
	,remove: function() {
		this.removeChild(this);
	}
	,onResize: function(pEvent) {
		var _g = 0;
		var _g1 = this.positionables;
		while(_g < _g1.length) {
			var lObj = _g1[_g];
			++_g;
			if(lObj.update) {
				if(lObj.align == "top" || lObj.align == "topLeft" || lObj.align == "topRight") lObj.offsetY = this.parent.y + lObj.item.y; else if(lObj.align == "bottom" || lObj.align == "bottomLeft" || lObj.align == "bottomRight") lObj.offsetY = com_isartdigital_utils_game_GameStage.getInstance().get_safeZone().height - this.parent.y - lObj.item.y;
				if(lObj.align == "left" || lObj.align == "topLeft" || lObj.align == "bottomLeft") lObj.offsetX = this.parent.x + lObj.item.x; else if(lObj.align == "right" || lObj.align == "topRight" || lObj.align == "bottomRight") lObj.offsetX = com_isartdigital_utils_game_GameStage.getInstance().get_safeZone().width - this.parent.x - lObj.item.x;
				lObj.update = false;
			}
			com_isartdigital_utils_ui_UIPosition.setPosition(lObj.item,lObj.align,lObj.offsetX,lObj.offsetY);
		}
	}
	,destroy: function() {
		this.close();
		com_isartdigital_utils_game_GameStage.getInstance().off("resize",$bind(this,this.onResize));
		com_isartdigital_utils_game_GameObject.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_utils_ui_UIComponent
});
var com_isartdigital_utils_ui_Screen = function() {
	com_isartdigital_utils_ui_UIComponent.call(this);
	this.modalImage = "assets/black_bg.png";
};
$hxClasses["com.isartdigital.utils.ui.Screen"] = com_isartdigital_utils_ui_Screen;
com_isartdigital_utils_ui_Screen.__name__ = ["com","isartdigital","utils","ui","Screen"];
com_isartdigital_utils_ui_Screen.__super__ = com_isartdigital_utils_ui_UIComponent;
com_isartdigital_utils_ui_Screen.prototype = $extend(com_isartdigital_utils_ui_UIComponent.prototype,{
	__class__: com_isartdigital_utils_ui_Screen
});
var com_isartdigital_ui_GraphicLoader = function() {
	com_isartdigital_utils_ui_Screen.call(this);
	var lBg = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "preload_bg.png"));
	lBg.anchor.set(0.5,0.5);
	this.addChild(lBg);
	this.loaderBar = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "preload.png"));
	this.loaderBar.anchor.y = 0.5;
	this.loaderBar.x = -this.loaderBar.width / 2;
	this.addChild(this.loaderBar);
	this.loaderBar.scale.x = 0;
};
$hxClasses["com.isartdigital.ui.GraphicLoader"] = com_isartdigital_ui_GraphicLoader;
com_isartdigital_ui_GraphicLoader.__name__ = ["com","isartdigital","ui","GraphicLoader"];
com_isartdigital_ui_GraphicLoader.getInstance = function() {
	if(com_isartdigital_ui_GraphicLoader.instance == null) com_isartdigital_ui_GraphicLoader.instance = new com_isartdigital_ui_GraphicLoader();
	return com_isartdigital_ui_GraphicLoader.instance;
};
com_isartdigital_ui_GraphicLoader.__super__ = com_isartdigital_utils_ui_Screen;
com_isartdigital_ui_GraphicLoader.prototype = $extend(com_isartdigital_utils_ui_Screen.prototype,{
	update: function(pProgress) {
		this.loaderBar.scale.x = pProgress;
	}
	,destroy: function() {
		com_isartdigital_ui_GraphicLoader.instance = null;
		com_isartdigital_utils_ui_Screen.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_ui_GraphicLoader
});
var com_isartdigital_ui_UIManager = function() {
	this.popins = [];
};
$hxClasses["com.isartdigital.ui.UIManager"] = com_isartdigital_ui_UIManager;
com_isartdigital_ui_UIManager.__name__ = ["com","isartdigital","ui","UIManager"];
com_isartdigital_ui_UIManager.getInstance = function() {
	if(com_isartdigital_ui_UIManager.instance == null) com_isartdigital_ui_UIManager.instance = new com_isartdigital_ui_UIManager();
	return com_isartdigital_ui_UIManager.instance;
};
com_isartdigital_ui_UIManager.prototype = {
	openScreen: function(pScreen) {
		this.closeScreens();
		com_isartdigital_utils_game_GameStage.getInstance().getScreensContainer().addChild(pScreen);
		pScreen.open();
	}
	,closeScreens: function() {
		var lContainer = com_isartdigital_utils_game_GameStage.getInstance().getScreensContainer();
		while(lContainer.children.length > 0) {
			var lCurrent;
			lCurrent = js_Boot.__cast(lContainer.getChildAt(lContainer.children.length - 1) , com_isartdigital_utils_ui_Screen);
			lCurrent.interactive = false;
			lContainer.removeChild(lCurrent);
			lCurrent.close();
		}
	}
	,openPopin: function(pPopin) {
		this.popins.push(pPopin);
		com_isartdigital_utils_game_GameStage.getInstance().getPopinsContainer().addChild(pPopin);
		pPopin.open();
	}
	,closeCurrentPopin: function() {
		if(this.popins.length == 0) return;
		var lCurrent = this.popins.pop();
		lCurrent.interactive = false;
		com_isartdigital_utils_game_GameStage.getInstance().getPopinsContainer().removeChild(lCurrent);
		lCurrent.close();
	}
	,openHud: function() {
		com_isartdigital_utils_game_GameStage.getInstance().getHudContainer().addChild(com_isartdigital_ui_hud_Hud.getInstance());
		com_isartdigital_ui_hud_Hud.getInstance().open();
	}
	,closeHud: function() {
		com_isartdigital_utils_game_GameStage.getInstance().getHudContainer().removeChild(com_isartdigital_ui_hud_Hud.getInstance());
		com_isartdigital_ui_hud_Hud.getInstance().close();
	}
	,startGame: function() {
		this.closeScreens();
		this.openHud();
	}
	,destroy: function() {
		com_isartdigital_ui_UIManager.instance = null;
	}
	,__class__: com_isartdigital_ui_UIManager
};
var com_isartdigital_utils_ui_Button = function() {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.boxType = com_isartdigital_utils_game_BoxType.NONE;
	this.interactive = true;
	this.buttonMode = true;
	this.on("mouseover",$bind(this,this._mouseOver));
	this.on("mousedown",$bind(this,this._mouseDown));
	this.on("click",$bind(this,this._click));
	this.on("mouseout",$bind(this,this._mouseOut));
	this.on("mouseupoutside",$bind(this,this._mouseOut));
	this.createText();
	this.start();
};
$hxClasses["com.isartdigital.utils.ui.Button"] = com_isartdigital_utils_ui_Button;
com_isartdigital_utils_ui_Button.__name__ = ["com","isartdigital","utils","ui","Button"];
com_isartdigital_utils_ui_Button.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_utils_ui_Button.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	createText: function() {
		this.upStyle = { font : "80px Arial", fill : "#000000", align : "center"};
		this.overStyle = { font : "80px Arial", fill : "#AAAAAA", align : "center"};
		this.downStyle = { font : "80px Arial", fill : "#FFFFFF", align : "center"};
		this.txt = new PIXI.Text("",this.upStyle);
		this.txt.anchor.set(0.5,0.5);
	}
	,setText: function(pText) {
		this.txt.text = pText;
	}
	,setModeNormal: function() {
		this.setState(this.DEFAULT_STATE);
		this.anim.gotoAndStop(0);
		this.addChild(this.txt);
		com_isartdigital_utils_game_StateGraphic.prototype.setModeNormal.call(this);
	}
	,_mouseVoid: function() {
	}
	,_click: function(pEvent) {
		this.anim.gotoAndStop(0);
		this.txt.style = this.upStyle;
	}
	,_mouseDown: function(pEvent) {
		this.anim.gotoAndStop(2);
		this.txt.style = this.downStyle;
	}
	,_mouseOver: function(pEvent) {
		this.anim.gotoAndStop(1);
		this.txt.style = this.overStyle;
	}
	,_mouseOut: function(pEvent) {
		this.anim.gotoAndStop(0);
		this.txt.style = this.upStyle;
	}
	,destroy: function() {
		this.off("mouseover",$bind(this,this._mouseOver));
		this.off("mousedown",$bind(this,this._mouseDown));
		this.off("click",$bind(this,this._click));
		this.off("mouseout",$bind(this,this._mouseOut));
		this.off("mouseupoutside",$bind(this,this._mouseOut));
		com_isartdigital_utils_game_StateGraphic.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_utils_ui_Button
});
var com_isartdigital_ui_buttons_BackButton = function() {
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.setState(this.DEFAULT_STATE);
	com_isartdigital_utils_ui_Button.call(this);
};
$hxClasses["com.isartdigital.ui.buttons.BackButton"] = com_isartdigital_ui_buttons_BackButton;
com_isartdigital_ui_buttons_BackButton.__name__ = ["com","isartdigital","ui","buttons","BackButton"];
com_isartdigital_ui_buttons_BackButton.__super__ = com_isartdigital_utils_ui_Button;
com_isartdigital_ui_buttons_BackButton.prototype = $extend(com_isartdigital_utils_ui_Button.prototype,{
	__class__: com_isartdigital_ui_buttons_BackButton
});
var com_isartdigital_ui_buttons_CreditButton = function() {
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.setState(this.DEFAULT_STATE);
	com_isartdigital_utils_ui_Button.call(this);
};
$hxClasses["com.isartdigital.ui.buttons.CreditButton"] = com_isartdigital_ui_buttons_CreditButton;
com_isartdigital_ui_buttons_CreditButton.__name__ = ["com","isartdigital","ui","buttons","CreditButton"];
com_isartdigital_ui_buttons_CreditButton.__super__ = com_isartdigital_utils_ui_Button;
com_isartdigital_ui_buttons_CreditButton.prototype = $extend(com_isartdigital_utils_ui_Button.prototype,{
	__class__: com_isartdigital_ui_buttons_CreditButton
});
var com_isartdigital_ui_buttons_HelpButton = function() {
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.setState(this.DEFAULT_STATE);
	com_isartdigital_utils_ui_Button.call(this);
};
$hxClasses["com.isartdigital.ui.buttons.HelpButton"] = com_isartdigital_ui_buttons_HelpButton;
com_isartdigital_ui_buttons_HelpButton.__name__ = ["com","isartdigital","ui","buttons","HelpButton"];
com_isartdigital_ui_buttons_HelpButton.__super__ = com_isartdigital_utils_ui_Button;
com_isartdigital_ui_buttons_HelpButton.prototype = $extend(com_isartdigital_utils_ui_Button.prototype,{
	__class__: com_isartdigital_ui_buttons_HelpButton
});
var com_isartdigital_ui_buttons_PlayButton = function() {
	this.factory = new com_isartdigital_utils_game_factory_MovieClipAnimFactory();
	this.setState(this.DEFAULT_STATE);
	com_isartdigital_utils_ui_Button.call(this);
};
$hxClasses["com.isartdigital.ui.buttons.PlayButton"] = com_isartdigital_ui_buttons_PlayButton;
com_isartdigital_ui_buttons_PlayButton.__name__ = ["com","isartdigital","ui","buttons","PlayButton"];
com_isartdigital_ui_buttons_PlayButton.__super__ = com_isartdigital_utils_ui_Button;
com_isartdigital_ui_buttons_PlayButton.prototype = $extend(com_isartdigital_utils_ui_Button.prototype,{
	__class__: com_isartdigital_ui_buttons_PlayButton
});
var com_isartdigital_ui_hud_Hud = function() {
	com_isartdigital_utils_ui_Screen.call(this);
	this._modal = false;
	this.hudTopLeft = new PIXI.Container();
	this.hudBottomLeft = new PIXI.Container();
	this.addChild(this.hudTopLeft);
	this.addChild(this.hudBottomLeft);
};
$hxClasses["com.isartdigital.ui.hud.Hud"] = com_isartdigital_ui_hud_Hud;
com_isartdigital_ui_hud_Hud.__name__ = ["com","isartdigital","ui","hud","Hud"];
com_isartdigital_ui_hud_Hud.getInstance = function() {
	if(com_isartdigital_ui_hud_Hud.instance == null) com_isartdigital_ui_hud_Hud.instance = new com_isartdigital_ui_hud_Hud();
	return com_isartdigital_ui_hud_Hud.instance;
};
com_isartdigital_ui_hud_Hud.__super__ = com_isartdigital_utils_ui_Screen;
com_isartdigital_ui_hud_Hud.prototype = $extend(com_isartdigital_utils_ui_Screen.prototype,{
	onResize: function(pEvent) {
	}
	,destroy: function() {
		com_isartdigital_ui_hud_Hud.instance = null;
		com_isartdigital_utils_ui_Screen.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_ui_hud_Hud
});
var com_isartdigital_utils_ui_Popin = function() {
	com_isartdigital_utils_ui_UIComponent.call(this);
};
$hxClasses["com.isartdigital.utils.ui.Popin"] = com_isartdigital_utils_ui_Popin;
com_isartdigital_utils_ui_Popin.__name__ = ["com","isartdigital","utils","ui","Popin"];
com_isartdigital_utils_ui_Popin.__super__ = com_isartdigital_utils_ui_UIComponent;
com_isartdigital_utils_ui_Popin.prototype = $extend(com_isartdigital_utils_ui_UIComponent.prototype,{
	__class__: com_isartdigital_utils_ui_Popin
});
var com_isartdigital_ui_popin_Annonce = function() {
	com_isartdigital_utils_ui_Popin.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "Popin_Annonce.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	console.log(com_isartdigital_game_LevelManager.getInstance().toPickObjects);
	this.obj_1 = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + com_isartdigital_game_LevelManager.getInstance().toPickObjects[0] + ".png"));
	this.obj_2 = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + com_isartdigital_game_LevelManager.getInstance().toPickObjects[1] + ".png"));
	this.obj_3 = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + com_isartdigital_game_LevelManager.getInstance().toPickObjects[2] + ".png"));
	this.obj_1.anchor.set(0.5,0.25);
	this.obj_2.anchor.set(0.5,0.25);
	this.obj_3.anchor.set(0.5,0.25);
	this.obj_1.scale.set(0.5,0.5);
	this.obj_2.scale.set(0.5,0.5);
	this.obj_3.scale.set(0.5,0.5);
	this.addChild(this.obj_1);
	this.addChild(this.obj_2);
	this.addChild(this.obj_3);
	this.obj_1.position.set(-this.width / 7,0);
	this.obj_2.position.set(0,0);
	this.obj_3.position.set(this.width / 7,0);
	this.interactive = true;
	this.buttonMode = true;
	this.once("click",$bind(this,this.onClick));
};
$hxClasses["com.isartdigital.ui.popin.Annonce"] = com_isartdigital_ui_popin_Annonce;
com_isartdigital_ui_popin_Annonce.__name__ = ["com","isartdigital","ui","popin","Annonce"];
com_isartdigital_ui_popin_Annonce.getInstance = function() {
	if(com_isartdigital_ui_popin_Annonce.instance == null) com_isartdigital_ui_popin_Annonce.instance = new com_isartdigital_ui_popin_Annonce();
	return com_isartdigital_ui_popin_Annonce.instance;
};
com_isartdigital_ui_popin_Annonce.__super__ = com_isartdigital_utils_ui_Popin;
com_isartdigital_ui_popin_Annonce.prototype = $extend(com_isartdigital_utils_ui_Popin.prototype,{
	onClick: function(pEvent) {
		com_isartdigital_utils_sounds_SoundManager.getSound("Ronronnement1").play();
		com_isartdigital_utils_sounds_SoundManager.getSound("MenuLoop").pause();
		com_isartdigital_ui_UIManager.getInstance().closeCurrentPopin();
		com_isartdigital_game_GameManager.getInstance().start();
	}
	,destroy: function() {
		com_isartdigital_ui_popin_Annonce.instance = null;
		com_isartdigital_utils_ui_Popin.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_ui_popin_Annonce
});
var com_isartdigital_ui_popin_Confirm = function() {
	com_isartdigital_utils_ui_Popin.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "Confirm.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	this.interactive = true;
	this.buttonMode = true;
	this.once("click",$bind(this,this.onClick));
	this.once("tap",$bind(this,this.onClick));
};
$hxClasses["com.isartdigital.ui.popin.Confirm"] = com_isartdigital_ui_popin_Confirm;
com_isartdigital_ui_popin_Confirm.__name__ = ["com","isartdigital","ui","popin","Confirm"];
com_isartdigital_ui_popin_Confirm.getInstance = function() {
	if(com_isartdigital_ui_popin_Confirm.instance == null) com_isartdigital_ui_popin_Confirm.instance = new com_isartdigital_ui_popin_Confirm();
	return com_isartdigital_ui_popin_Confirm.instance;
};
com_isartdigital_ui_popin_Confirm.__super__ = com_isartdigital_utils_ui_Popin;
com_isartdigital_ui_popin_Confirm.prototype = $extend(com_isartdigital_utils_ui_Popin.prototype,{
	test: function(pEvent) {
		console.log(pEvent);
	}
	,onClick: function(pEvent) {
		com_isartdigital_ui_UIManager.getInstance().closeCurrentPopin();
		com_isartdigital_game_GameManager.getInstance().start();
	}
	,destroy: function() {
		com_isartdigital_ui_popin_Confirm.instance = null;
		com_isartdigital_utils_ui_Popin.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_ui_popin_Confirm
});
var com_isartdigital_ui_popin_WinPopin = function() {
	this.txtStyle = { fill : "white", stroke : "black", strokeThickness : 5, font : "62px tao"};
	com_isartdigital_utils_ui_Popin.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "Scoring.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	this.interactive = true;
	this.buttonMode = true;
	var _g1 = 0;
	var _g = com_isartdigital_game_sprites_Arrow.arrowsArray.length;
	while(_g1 < _g) {
		var i = _g1++;
		if(com_isartdigital_game_sprites_Arrow.arrowsArray[i].parent != null) com_isartdigital_game_sprites_Arrow.arrowsArray[i].remove();
	}
	var lScreen = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(com_isartdigital_utils_game_GameStage.getInstance());
	com_isartdigital_game_GameManager.getInstance().pause = true;
	var txt = com_isartdigital_game_sprites_Score.getInstance().txt;
	txt.anchor.set(0.5,0.5);
	txt.position.set(this.x,lScreen.y + lScreen.height / 2 / 3);
	this.addChild(txt);
};
$hxClasses["com.isartdigital.ui.popin.WinPopin"] = com_isartdigital_ui_popin_WinPopin;
com_isartdigital_ui_popin_WinPopin.__name__ = ["com","isartdigital","ui","popin","WinPopin"];
com_isartdigital_ui_popin_WinPopin.getInstance = function() {
	if(com_isartdigital_ui_popin_WinPopin.instance == null) com_isartdigital_ui_popin_WinPopin.instance = new com_isartdigital_ui_popin_WinPopin();
	return com_isartdigital_ui_popin_WinPopin.instance;
};
com_isartdigital_ui_popin_WinPopin.__super__ = com_isartdigital_utils_ui_Popin;
com_isartdigital_ui_popin_WinPopin.prototype = $extend(com_isartdigital_utils_ui_Popin.prototype,{
	destroy: function() {
		com_isartdigital_ui_popin_WinPopin.instance = null;
	}
	,__class__: com_isartdigital_ui_popin_WinPopin
});
var com_isartdigital_ui_screens_Credit = function() {
	com_isartdigital_utils_ui_Popin.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "Credits.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	this.interactive = true;
	this.buttonMode = true;
	this.once("click",$bind(this,this.onClick));
};
$hxClasses["com.isartdigital.ui.screens.Credit"] = com_isartdigital_ui_screens_Credit;
com_isartdigital_ui_screens_Credit.__name__ = ["com","isartdigital","ui","screens","Credit"];
com_isartdigital_ui_screens_Credit.getInstance = function() {
	if(com_isartdigital_ui_screens_Credit.instance == null) com_isartdigital_ui_screens_Credit.instance = new com_isartdigital_ui_screens_Credit();
	return com_isartdigital_ui_screens_Credit.instance;
};
com_isartdigital_ui_screens_Credit.__super__ = com_isartdigital_utils_ui_Popin;
com_isartdigital_ui_screens_Credit.prototype = $extend(com_isartdigital_utils_ui_Popin.prototype,{
	onClick: function(pEvent) {
		com_isartdigital_ui_UIManager.getInstance().closeCurrentPopin();
	}
	,destroy: function() {
		com_isartdigital_ui_screens_Credit.instance = null;
	}
	,__class__: com_isartdigital_ui_screens_Credit
});
var com_isartdigital_ui_screens_Help = function() {
	com_isartdigital_utils_ui_Popin.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "Help.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	this.interactive = true;
	this.buttonMode = true;
	this.once("click",$bind(this,this.onClick));
};
$hxClasses["com.isartdigital.ui.screens.Help"] = com_isartdigital_ui_screens_Help;
com_isartdigital_ui_screens_Help.__name__ = ["com","isartdigital","ui","screens","Help"];
com_isartdigital_ui_screens_Help.getInstance = function() {
	if(com_isartdigital_ui_screens_Help.instance == null) com_isartdigital_ui_screens_Help.instance = new com_isartdigital_ui_screens_Help();
	return com_isartdigital_ui_screens_Help.instance;
};
com_isartdigital_ui_screens_Help.__super__ = com_isartdigital_utils_ui_Popin;
com_isartdigital_ui_screens_Help.prototype = $extend(com_isartdigital_utils_ui_Popin.prototype,{
	onClick: function(pEvent) {
		com_isartdigital_ui_UIManager.getInstance().closeCurrentPopin();
	}
	,destroy: function() {
		com_isartdigital_ui_screens_Help.instance = null;
	}
	,__class__: com_isartdigital_ui_screens_Help
});
var com_isartdigital_ui_screens_TitleCard = function() {
	this.haveASound = false;
	this.countdown = 45;
	com_isartdigital_utils_ui_Screen.call(this);
	this.background = new PIXI.Sprite(PIXI.Texture.fromImage(com_isartdigital_utils_Config.get_assetsPath() + "TitleCard_bg.png"));
	this.background.anchor.set(0.5,0.5);
	this.addChild(this.background);
	this.playButton = new com_isartdigital_ui_buttons_PlayButton();
	this.playButton.position.set(-this.playButton.width / 2,-com_isartdigital_utils_game_GameStage.getInstance().height);
	this.buttonPlayFinalPosition = new PIXI.Point(-this.playButton.width / 2,com_isartdigital_utils_game_GameStage.getInstance().height * 0.33333333333333331);
	this.playButton.scale.x = this.playButton.scale.y *= 0.6;
	this.addChild(this.playButton);
	this.creditsButton = new com_isartdigital_ui_buttons_CreditButton();
	this.creditsButton.position.set(-com_isartdigital_utils_game_GameStage.getInstance().width,com_isartdigital_utils_game_GameStage.getInstance().height * 0.33333333333333331);
	this.buttonCreditFinalPosition = new PIXI.Point(this.buttonPlayFinalPosition.x - this.creditsButton.width * 1.25,com_isartdigital_utils_game_GameStage.getInstance().height * 0.33333333333333331);
	this.creditsButton.scale.x = this.creditsButton.scale.x *= 0.6;
	this.addChild(this.creditsButton);
	this.helpButton = new com_isartdigital_ui_buttons_HelpButton();
	this.helpButton.position.set(com_isartdigital_utils_game_GameStage.getInstance().width,com_isartdigital_utils_game_GameStage.getInstance().height * 0.33333333333333331);
	this.buttonHelpFinalPosition = new PIXI.Point(this.buttonPlayFinalPosition.x + this.helpButton.width * 1.5,com_isartdigital_utils_game_GameStage.getInstance().height * 0.33333333333333331);
	this.helpButton.scale.x = this.helpButton.scale.x *= 0.6;
	this.addChild(this.helpButton);
	this.addChild(com_isartdigital_game_sprites_Animation_$titlecard.getInstance());
	com_isartdigital_game_sprites_Animation_$titlecard.getInstance().position.set(-com_isartdigital_game_sprites_Animation_$titlecard.getInstance().width / 1.75,-com_isartdigital_game_sprites_Animation_$titlecard.getInstance().height / 3);
	this.playButton.click = $bind(this,this.onClickOnPlay);
	this.creditsButton.click = $bind(this,this.onClickOnCredit);
	this.helpButton.click = $bind(this,this.onClickOnHelp);
	com_isartdigital_Main.getInstance().on("gameLoop",$bind(this,this.TCLoop));
};
$hxClasses["com.isartdigital.ui.screens.TitleCard"] = com_isartdigital_ui_screens_TitleCard;
com_isartdigital_ui_screens_TitleCard.__name__ = ["com","isartdigital","ui","screens","TitleCard"];
com_isartdigital_ui_screens_TitleCard.getInstance = function() {
	if(com_isartdigital_ui_screens_TitleCard.instance == null) com_isartdigital_ui_screens_TitleCard.instance = new com_isartdigital_ui_screens_TitleCard();
	return com_isartdigital_ui_screens_TitleCard.instance;
};
com_isartdigital_ui_screens_TitleCard.__super__ = com_isartdigital_utils_ui_Screen;
com_isartdigital_ui_screens_TitleCard.prototype = $extend(com_isartdigital_utils_ui_Screen.prototype,{
	onClickOnPlay: function(pData) {
		com_isartdigital_utils_sounds_SoundManager.getSound("Ronronnement1").play();
		com_isartdigital_game_LevelManager.getInstance().setObjects();
		com_isartdigital_ui_UIManager.getInstance().openPopin(com_isartdigital_ui_popin_Annonce.getInstance());
	}
	,onClickOnCredit: function(pData) {
		com_isartdigital_utils_sounds_SoundManager.getSound("Ronronnement2").play();
		com_isartdigital_ui_UIManager.getInstance().openPopin(com_isartdigital_ui_screens_Credit.getInstance());
	}
	,onClickOnHelp: function(pData) {
		com_isartdigital_utils_sounds_SoundManager.getSound("Ronronnement2").play();
		com_isartdigital_ui_UIManager.getInstance().openPopin(com_isartdigital_ui_screens_Help.getInstance());
	}
	,TCLoop: function(pEvent) {
		if(!this.haveASound) {
			com_isartdigital_utils_sounds_SoundManager.getSound("MenuLoop").play();
			this.haveASound = true;
		}
		if(this.countdown > 0) {
			this.countdown--;
			return;
		}
		if(this.tweenOn) {
			this.playButton.position.y += (this.buttonPlayFinalPosition.y - this.playButton.position.y) * 0.1;
			this.creditsButton.position.x += (this.buttonCreditFinalPosition.x - this.creditsButton.position.x) * 0.1;
			this.helpButton.position.x += (this.buttonHelpFinalPosition.x - this.helpButton.position.x) * 0.1;
			if(this.playButton.position.y - this.buttonPlayFinalPosition.y > -5 && this.creditsButton.position.x - this.buttonCreditFinalPosition.x > -50 && this.helpButton.position.x - this.buttonHelpFinalPosition.x > 50) {
				this.playButton.position.y = this.buttonPlayFinalPosition.y;
				this.creditsButton.position.x = this.buttonCreditFinalPosition.x;
				this.helpButton.position.x = this.buttonHelpFinalPosition.x;
				this.tweenOn = false;
			}
		}
		this.playButton.scale.x = 1 + Math.sin(this.playBlobCount) * 0.04;
		this.playButton.scale.y = 1 + Math.cos(this.playBlobCount) * 0.04;
		this.playBlobCount += 0.1;
		this.creditsButton.scale.x = 1 + Math.sin(this.creditBlobCount) * 0.04;
		this.creditsButton.scale.y = 1 + Math.cos(this.creditBlobCount) * 0.04;
		this.creditBlobCount += 0.1;
		this.helpButton.scale.x = 1 + Math.sin(this.helpBlobCount) * 0.04;
		this.helpButton.scale.y = 1 + Math.cos(this.helpBlobCount) * 0.04;
		this.helpBlobCount += 0.1;
	}
	,open: function() {
		com_isartdigital_utils_ui_Screen.prototype.open.call(this);
		this.playBlobCount = 0;
		this.creditBlobCount = 0;
		this.helpBlobCount = 0;
		this.tweenOn = true;
	}
	,close: function() {
		com_isartdigital_Main.getInstance().off("gameLoop",$bind(this,this.TCLoop));
		com_isartdigital_utils_ui_Screen.prototype.close.call(this);
	}
	,destroy: function() {
		com_isartdigital_ui_screens_TitleCard.instance = null;
		com_isartdigital_utils_ui_Screen.prototype.destroy.call(this);
	}
	,__class__: com_isartdigital_ui_screens_TitleCard
});
var com_isartdigital_utils_Config = function() { };
$hxClasses["com.isartdigital.utils.Config"] = com_isartdigital_utils_Config;
com_isartdigital_utils_Config.__name__ = ["com","isartdigital","utils","Config"];
com_isartdigital_utils_Config.init = function(pConfig) {
	var _g = 0;
	var _g1 = Reflect.fields(pConfig);
	while(_g < _g1.length) {
		var i = _g1[_g];
		++_g;
		Reflect.setField(com_isartdigital_utils_Config._data,i,Reflect.field(pConfig,i));
	}
	if(com_isartdigital_utils_Config._data.version == null) com_isartdigital_utils_Config._data.version = "0.0.0";
	if(com_isartdigital_utils_Config._data.language == null) {
		var _this = window.navigator.language;
		com_isartdigital_utils_Config._data.language = HxOverrides.substr(_this,0,2);
	}
	if(com_isartdigital_utils_Config._data.languages == []) com_isartdigital_utils_Config._data.languages.push(com_isartdigital_utils_Config._data.language);
	if(com_isartdigital_utils_Config._data.debug == null) com_isartdigital_utils_Config._data.debug = false;
	if(com_isartdigital_utils_Config._data.fps == null) com_isartdigital_utils_Config._data.fps = false;
	if(com_isartdigital_utils_Config._data.qrcode == null) com_isartdigital_utils_Config._data.qrcode = false;
	if(com_isartdigital_utils_Config._data.langPath == null) com_isartdigital_utils_Config._data.langPath = "";
	if(com_isartdigital_utils_Config._data.txtsPath == null) com_isartdigital_utils_Config._data.txtsPath = "";
	if(com_isartdigital_utils_Config._data.assetsPath == null) com_isartdigital_utils_Config._data.assetsPath = "";
	if(com_isartdigital_utils_Config._data.fontsPath == null) com_isartdigital_utils_Config._data.fontsPath = "";
	if(com_isartdigital_utils_Config._data.soundsPath == null) com_isartdigital_utils_Config._data.soundsPath = "sounds/";
};
com_isartdigital_utils_Config.get_data = function() {
	return com_isartdigital_utils_Config._data;
};
com_isartdigital_utils_Config.get_version = function() {
	return com_isartdigital_utils_Config._data.version;
};
com_isartdigital_utils_Config.get_language = function() {
	return com_isartdigital_utils_Config.get_data().language;
};
com_isartdigital_utils_Config.get_languages = function() {
	return com_isartdigital_utils_Config.get_data().languages;
};
com_isartdigital_utils_Config.get_debug = function() {
	return com_isartdigital_utils_Config.get_data().debug;
};
com_isartdigital_utils_Config.get_fps = function() {
	return com_isartdigital_utils_Config.get_data().fps;
};
com_isartdigital_utils_Config.get_qrcode = function() {
	return com_isartdigital_utils_Config.get_data().qrcode;
};
com_isartdigital_utils_Config.get_langPath = function() {
	return com_isartdigital_utils_Config._data.langPath;
};
com_isartdigital_utils_Config.get_txtsPath = function() {
	return com_isartdigital_utils_Config._data.txtsPath;
};
com_isartdigital_utils_Config.get_assetsPath = function() {
	return com_isartdigital_utils_Config._data.assetsPath;
};
com_isartdigital_utils_Config.get_fontsPath = function() {
	return com_isartdigital_utils_Config._data.fontsPath;
};
com_isartdigital_utils_Config.get_soundsPath = function() {
	return com_isartdigital_utils_Config._data.soundsPath;
};
var com_isartdigital_utils_Debug = function() {
};
$hxClasses["com.isartdigital.utils.Debug"] = com_isartdigital_utils_Debug;
com_isartdigital_utils_Debug.__name__ = ["com","isartdigital","utils","Debug"];
com_isartdigital_utils_Debug.getInstance = function() {
	if(com_isartdigital_utils_Debug.instance == null) com_isartdigital_utils_Debug.instance = new com_isartdigital_utils_Debug();
	return com_isartdigital_utils_Debug.instance;
};
com_isartdigital_utils_Debug.error = function(pArg) {
	console.error(pArg);
};
com_isartdigital_utils_Debug.warn = function(pArg) {
	console.warn(pArg);
};
com_isartdigital_utils_Debug.table = function(pArg) {
	console.table(pArg);
};
com_isartdigital_utils_Debug.info = function(pArg) {
	console.info(pArg);
};
com_isartdigital_utils_Debug.prototype = {
	init: function() {
		if(com_isartdigital_utils_Config.get_fps()) {
			this.fps = new FPSMeter();
			this.fps.show();
			this.fps.showFps();
			this.ticker = new PIXI.ticker.Ticker();
			this.ticker.add($bind(this,this.updateFps));
			this.ticker.start();
		}
		if(com_isartdigital_utils_Config.get_qrcode() && !com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) {
			var lQr = new Image();
			lQr.style.position = "absolute";
			lQr.style.right = "0px";
			lQr.style.bottom = "0px";
			var lSize = Std["int"](0.35 * com_isartdigital_utils_system_DeviceCapabilities.getSizeFactor());
			lQr.src = "https://chart.googleapis.com/chart?chs=" + lSize + "x" + lSize + "&cht=qr&chl=" + window.location.href + "&choe=UTF-8";
			window.document.body.appendChild(lQr);
		}
	}
	,updateFps: function() {
		this.fps.tick();
		this.fps.tickStart();
	}
	,destroy: function() {
		this.ticker.stop();
	}
	,__class__: com_isartdigital_utils_Debug
};
var com_isartdigital_utils_events_EventType = function() { };
$hxClasses["com.isartdigital.utils.events.EventType"] = com_isartdigital_utils_events_EventType;
com_isartdigital_utils_events_EventType.__name__ = ["com","isartdigital","utils","events","EventType"];
var com_isartdigital_utils_events_LoadEventType = function() { };
$hxClasses["com.isartdigital.utils.events.LoadEventType"] = com_isartdigital_utils_events_LoadEventType;
com_isartdigital_utils_events_LoadEventType.__name__ = ["com","isartdigital","utils","events","LoadEventType"];
com_isartdigital_utils_events_LoadEventType.__super__ = com_isartdigital_utils_events_EventType;
com_isartdigital_utils_events_LoadEventType.prototype = $extend(com_isartdigital_utils_events_EventType.prototype,{
	__class__: com_isartdigital_utils_events_LoadEventType
});
var com_isartdigital_utils_events_MouseEventType = function() { };
$hxClasses["com.isartdigital.utils.events.MouseEventType"] = com_isartdigital_utils_events_MouseEventType;
com_isartdigital_utils_events_MouseEventType.__name__ = ["com","isartdigital","utils","events","MouseEventType"];
com_isartdigital_utils_events_MouseEventType.__super__ = com_isartdigital_utils_events_EventType;
com_isartdigital_utils_events_MouseEventType.prototype = $extend(com_isartdigital_utils_events_EventType.prototype,{
	__class__: com_isartdigital_utils_events_MouseEventType
});
var com_isartdigital_utils_events_TouchEventType = function() { };
$hxClasses["com.isartdigital.utils.events.TouchEventType"] = com_isartdigital_utils_events_TouchEventType;
com_isartdigital_utils_events_TouchEventType.__name__ = ["com","isartdigital","utils","events","TouchEventType"];
com_isartdigital_utils_events_TouchEventType.__super__ = com_isartdigital_utils_events_EventType;
com_isartdigital_utils_events_TouchEventType.prototype = $extend(com_isartdigital_utils_events_EventType.prototype,{
	__class__: com_isartdigital_utils_events_TouchEventType
});
var com_isartdigital_utils_game_BoxType = { __ename__ : true, __constructs__ : ["NONE","SIMPLE","MULTIPLE","SELF"] };
com_isartdigital_utils_game_BoxType.NONE = ["NONE",0];
com_isartdigital_utils_game_BoxType.NONE.toString = $estr;
com_isartdigital_utils_game_BoxType.NONE.__enum__ = com_isartdigital_utils_game_BoxType;
com_isartdigital_utils_game_BoxType.SIMPLE = ["SIMPLE",1];
com_isartdigital_utils_game_BoxType.SIMPLE.toString = $estr;
com_isartdigital_utils_game_BoxType.SIMPLE.__enum__ = com_isartdigital_utils_game_BoxType;
com_isartdigital_utils_game_BoxType.MULTIPLE = ["MULTIPLE",2];
com_isartdigital_utils_game_BoxType.MULTIPLE.toString = $estr;
com_isartdigital_utils_game_BoxType.MULTIPLE.__enum__ = com_isartdigital_utils_game_BoxType;
com_isartdigital_utils_game_BoxType.SELF = ["SELF",3];
com_isartdigital_utils_game_BoxType.SELF.toString = $estr;
com_isartdigital_utils_game_BoxType.SELF.__enum__ = com_isartdigital_utils_game_BoxType;
var com_isartdigital_utils_game_CollisionManager = function() {
};
$hxClasses["com.isartdigital.utils.game.CollisionManager"] = com_isartdigital_utils_game_CollisionManager;
com_isartdigital_utils_game_CollisionManager.__name__ = ["com","isartdigital","utils","game","CollisionManager"];
com_isartdigital_utils_game_CollisionManager.hitTestObject = function(pObjectA,pObjectB) {
	return com_isartdigital_utils_game_CollisionManager.getIntersection(pObjectA.getBounds(),pObjectB.getBounds());
};
com_isartdigital_utils_game_CollisionManager.hitTestPoint = function(pItem,pGlobalPoint) {
	var lPoint = pItem.toLocal(pGlobalPoint);
	var x = lPoint.x;
	var y = lPoint.y;
	if(pItem.hitArea != null && pItem.hitArea.contains != null) return pItem.hitArea.contains(x,y); else if(js_Boot.__instanceof(pItem,PIXI.Sprite)) {
		var lSprite;
		lSprite = js_Boot.__cast(pItem , PIXI.Sprite);
		var lWidth = lSprite.texture.frame.width;
		var lHeight = lSprite.texture.frame.height;
		var lX1 = -lWidth * lSprite.anchor.x;
		var lY1;
		if(x > lX1 && x < lX1 + lWidth) {
			lY1 = -lHeight * lSprite.anchor.y;
			if(y > lY1 && y < lY1 + lHeight) return true;
		}
	} else if(js_Boot.__instanceof(pItem,PIXI.Graphics)) {
		var lGraphicsData = pItem.graphicsData;
		var _g1 = 0;
		var _g = lGraphicsData.length;
		while(_g1 < _g) {
			var i = _g1++;
			var lData = lGraphicsData[i];
			if(!lData.fill) continue;
			if(lData.shape != null && lData.shape.contains(x,y)) return true;
		}
	} else if(js_Boot.__instanceof(pItem,PIXI.Container)) {
		var lContainer;
		lContainer = js_Boot.__cast(pItem , PIXI.Container);
		var lLength = lContainer.children.length;
		var _g2 = 0;
		while(_g2 < lLength) {
			var i1 = _g2++;
			if(com_isartdigital_utils_game_CollisionManager.hitTestPoint(lContainer.children[i1],pGlobalPoint)) return true;
		}
	}
	return false;
};
com_isartdigital_utils_game_CollisionManager.hasCollision = function(pHitBoxA,pHitBoxB,pPointsA,pPointsB) {
	if(pHitBoxA == null || pHitBoxB == null) return false;
	if(!com_isartdigital_utils_game_CollisionManager.hitTestObject(pHitBoxA,pHitBoxB)) return false;
	if(pPointsA == null && pPointsB == null) return true;
	if(pPointsA != null) return com_isartdigital_utils_game_CollisionManager.testPoints(pPointsA,pHitBoxB);
	if(pPointsB != null) return com_isartdigital_utils_game_CollisionManager.testPoints(pPointsB,pHitBoxA);
	return false;
};
com_isartdigital_utils_game_CollisionManager.getIntersection = function(pRectA,pRectB) {
	return !(pRectB.x > pRectA.x + pRectA.width || pRectB.x + pRectB.width < pRectA.x || pRectB.y > pRectA.y + pRectA.height || pRectB.y + pRectB.height < pRectA.y);
};
com_isartdigital_utils_game_CollisionManager.testPoints = function(pHitPoints,pHitBox) {
	var lLength = pHitPoints.length;
	var _g = 0;
	while(_g < lLength) {
		var i = _g++;
		if(com_isartdigital_utils_game_CollisionManager.hitTestPoint(pHitBox,pHitPoints[i])) return true;
	}
	return false;
};
com_isartdigital_utils_game_CollisionManager.prototype = {
	__class__: com_isartdigital_utils_game_CollisionManager
};
var com_isartdigital_utils_game_GameStage = function() {
	this._safeZone = new PIXI.Rectangle(0,0,2048,1366);
	this._scaleMode = com_isartdigital_utils_game_GameStageScale.SHOW_ALL;
	this._alignMode = com_isartdigital_utils_game_GameStageAlign.CENTER;
	PIXI.Container.call(this);
	this.decorContainer = new PIXI.Container();
	this.addChild(this.decorContainer);
	this.gameContainer = new PIXI.Container();
	this.addChild(this.gameContainer);
	this.screensContainer = new PIXI.Container();
	this.addChild(this.screensContainer);
	this.hudContainer = new PIXI.Container();
	this.addChild(this.hudContainer);
	this.popinsContainer = new PIXI.Container();
	this.addChild(this.popinsContainer);
};
$hxClasses["com.isartdigital.utils.game.GameStage"] = com_isartdigital_utils_game_GameStage;
com_isartdigital_utils_game_GameStage.__name__ = ["com","isartdigital","utils","game","GameStage"];
com_isartdigital_utils_game_GameStage.getInstance = function() {
	if(com_isartdigital_utils_game_GameStage.instance == null) com_isartdigital_utils_game_GameStage.instance = new com_isartdigital_utils_game_GameStage();
	return com_isartdigital_utils_game_GameStage.instance;
};
com_isartdigital_utils_game_GameStage.__super__ = PIXI.Container;
com_isartdigital_utils_game_GameStage.prototype = $extend(PIXI.Container.prototype,{
	init: function(pRender,pSafeZoneWidth,pSafeZoneHeight,pCenterGameContainer,pCenterScreensContainer,pCenterPopinContainer) {
		if(pCenterPopinContainer == null) pCenterPopinContainer = true;
		if(pCenterScreensContainer == null) pCenterScreensContainer = true;
		if(pCenterGameContainer == null) pCenterGameContainer = false;
		if(pSafeZoneHeight == null) pSafeZoneHeight = 2048;
		if(pSafeZoneWidth == null) pSafeZoneWidth = 2048;
		this._safeZone = new PIXI.Rectangle(0,0,_$UInt_UInt_$Impl_$.toFloat(pSafeZoneWidth),_$UInt_UInt_$Impl_$.toFloat(pSafeZoneHeight));
		if(pCenterGameContainer) {
			this.gameContainer.x = this.get_safeZone().width / 2;
			this.gameContainer.y = this.get_safeZone().height / 2;
		}
		if(pCenterScreensContainer) {
			this.screensContainer.x = this.get_safeZone().width / 2;
			this.screensContainer.y = this.get_safeZone().height / 2;
		}
		if(pCenterPopinContainer) {
			this.popinsContainer.x = this.get_safeZone().width / 2;
			this.popinsContainer.y = this.get_safeZone().height / 2;
		}
		this._render = pRender;
	}
	,resize: function() {
		var lWidth = com_isartdigital_utils_system_DeviceCapabilities.get_width();
		var lHeight = com_isartdigital_utils_system_DeviceCapabilities.get_height();
		var lRatio = Math.round(10000 * Math.min((function($this) {
			var $r;
			var b = $this.get_safeZone().width;
			$r = _$UInt_UInt_$Impl_$.toFloat(lWidth) / b;
			return $r;
		}(this)),(function($this) {
			var $r;
			var b1 = $this.get_safeZone().height;
			$r = _$UInt_UInt_$Impl_$.toFloat(lHeight) / b1;
			return $r;
		}(this)))) / 10000;
		if(this.get_scaleMode() == com_isartdigital_utils_game_GameStageScale.SHOW_ALL) this.scale.set(lRatio,lRatio); else this.scale.set(com_isartdigital_utils_system_DeviceCapabilities.textureRatio,com_isartdigital_utils_system_DeviceCapabilities.textureRatio);
		if(this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.LEFT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.TOP_LEFT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.BOTTOM_LEFT) this.x = 0; else if(this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.RIGHT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.TOP_RIGHT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.BOTTOM_RIGHT) {
			var b2 = this.get_safeZone().width * this.scale.x;
			this.x = _$UInt_UInt_$Impl_$.toFloat(lWidth) - b2;
		} else this.x = (function($this) {
			var $r;
			var b3 = $this.get_safeZone().width * $this.scale.x;
			$r = _$UInt_UInt_$Impl_$.toFloat(lWidth) - b3;
			return $r;
		}(this)) / 2;
		if(this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.TOP || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.TOP_LEFT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.TOP_RIGHT) this.y = 0; else if(this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.BOTTOM || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.BOTTOM_LEFT || this.get_alignMode() == com_isartdigital_utils_game_GameStageAlign.BOTTOM_RIGHT) {
			var b4 = this.get_safeZone().height * this.scale.y;
			this.y = _$UInt_UInt_$Impl_$.toFloat(lHeight) - b4;
		} else this.y = (function($this) {
			var $r;
			var b5 = $this.get_safeZone().height * $this.scale.y;
			$r = _$UInt_UInt_$Impl_$.toFloat(lHeight) - b5;
			return $r;
		}(this)) / 2;
		this.render();
		this.emit("resize",{ width : lWidth, height : lHeight});
	}
	,render: function() {
		if(this._render != null) this._render();
	}
	,get_alignMode: function() {
		return this._alignMode;
	}
	,set_alignMode: function(pAlign) {
		this._alignMode = pAlign;
		this.resize();
		return this._alignMode;
	}
	,get_scaleMode: function() {
		return this._scaleMode;
	}
	,set_scaleMode: function(pScale) {
		this._scaleMode = pScale;
		this.resize();
		return this._scaleMode;
	}
	,get_safeZone: function() {
		return this._safeZone;
	}
	,getDecorContainer: function() {
		return this.decorContainer;
	}
	,getGameContainer: function() {
		return this.gameContainer;
	}
	,getScreensContainer: function() {
		return this.screensContainer;
	}
	,getHudContainer: function() {
		return this.hudContainer;
	}
	,getPopinsContainer: function() {
		return this.popinsContainer;
	}
	,destroy: function() {
		com_isartdigital_utils_game_GameStage.instance = null;
		PIXI.Container.prototype.destroy.call(this,true);
	}
	,__class__: com_isartdigital_utils_game_GameStage
});
var com_isartdigital_utils_game_GameStageAlign = { __ename__ : true, __constructs__ : ["TOP","TOP_LEFT","TOP_RIGHT","CENTER","LEFT","RIGHT","BOTTOM","BOTTOM_LEFT","BOTTOM_RIGHT"] };
com_isartdigital_utils_game_GameStageAlign.TOP = ["TOP",0];
com_isartdigital_utils_game_GameStageAlign.TOP.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.TOP.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.TOP_LEFT = ["TOP_LEFT",1];
com_isartdigital_utils_game_GameStageAlign.TOP_LEFT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.TOP_LEFT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.TOP_RIGHT = ["TOP_RIGHT",2];
com_isartdigital_utils_game_GameStageAlign.TOP_RIGHT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.TOP_RIGHT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.CENTER = ["CENTER",3];
com_isartdigital_utils_game_GameStageAlign.CENTER.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.CENTER.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.LEFT = ["LEFT",4];
com_isartdigital_utils_game_GameStageAlign.LEFT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.LEFT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.RIGHT = ["RIGHT",5];
com_isartdigital_utils_game_GameStageAlign.RIGHT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.RIGHT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.BOTTOM = ["BOTTOM",6];
com_isartdigital_utils_game_GameStageAlign.BOTTOM.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.BOTTOM.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.BOTTOM_LEFT = ["BOTTOM_LEFT",7];
com_isartdigital_utils_game_GameStageAlign.BOTTOM_LEFT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.BOTTOM_LEFT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
com_isartdigital_utils_game_GameStageAlign.BOTTOM_RIGHT = ["BOTTOM_RIGHT",8];
com_isartdigital_utils_game_GameStageAlign.BOTTOM_RIGHT.toString = $estr;
com_isartdigital_utils_game_GameStageAlign.BOTTOM_RIGHT.__enum__ = com_isartdigital_utils_game_GameStageAlign;
var com_isartdigital_utils_game_GameStageScale = { __ename__ : true, __constructs__ : ["NO_SCALE","SHOW_ALL"] };
com_isartdigital_utils_game_GameStageScale.NO_SCALE = ["NO_SCALE",0];
com_isartdigital_utils_game_GameStageScale.NO_SCALE.toString = $estr;
com_isartdigital_utils_game_GameStageScale.NO_SCALE.__enum__ = com_isartdigital_utils_game_GameStageScale;
com_isartdigital_utils_game_GameStageScale.SHOW_ALL = ["SHOW_ALL",1];
com_isartdigital_utils_game_GameStageScale.SHOW_ALL.toString = $estr;
com_isartdigital_utils_game_GameStageScale.SHOW_ALL.__enum__ = com_isartdigital_utils_game_GameStageScale;
var com_isartdigital_utils_game_factory_AnimFactory = function() {
};
$hxClasses["com.isartdigital.utils.game.factory.AnimFactory"] = com_isartdigital_utils_game_factory_AnimFactory;
com_isartdigital_utils_game_factory_AnimFactory.__name__ = ["com","isartdigital","utils","game","factory","AnimFactory"];
com_isartdigital_utils_game_factory_AnimFactory.prototype = {
	getAnim: function() {
		return this.anim;
	}
	,create: function(pID) {
		return null;
	}
	,update: function(pId) {
	}
	,setFrame: function(pAutoPlay,pStart) {
		if(pStart == null) pStart = 0;
		if(pAutoPlay == null) pAutoPlay = true;
	}
	,__class__: com_isartdigital_utils_game_factory_AnimFactory
};
var com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory = function() {
	com_isartdigital_utils_game_factory_AnimFactory.call(this);
};
$hxClasses["com.isartdigital.utils.game.factory.FlumpSpriteAnimFactory"] = com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory;
com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory.__name__ = ["com","isartdigital","utils","game","factory","FlumpSpriteAnimFactory"];
com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory.__super__ = com_isartdigital_utils_game_factory_AnimFactory;
com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory.prototype = $extend(com_isartdigital_utils_game_factory_AnimFactory.prototype,{
	getAnim: function() {
		if(this.anim != null) {
			this.anim.parent.removeChild(this.anim);
			this.anim.destroy();
			this.anim = null;
		}
		return com_isartdigital_utils_game_factory_AnimFactory.prototype.getAnim.call(this);
	}
	,create: function(pID) {
		this.anim = new pixi_display_FlumpSprite(pID);
		return this.anim;
	}
	,setFrame: function(pAutoPlay,pStart) {
		if(pStart == null) pStart = 0;
		if(pAutoPlay == null) pAutoPlay = true;
	}
	,__class__: com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory
});
var com_isartdigital_utils_game_factory_MovieClipAnimFactory = function() {
	com_isartdigital_utils_game_factory_AnimFactory.call(this);
};
$hxClasses["com.isartdigital.utils.game.factory.MovieClipAnimFactory"] = com_isartdigital_utils_game_factory_MovieClipAnimFactory;
com_isartdigital_utils_game_factory_MovieClipAnimFactory.__name__ = ["com","isartdigital","utils","game","factory","MovieClipAnimFactory"];
com_isartdigital_utils_game_factory_MovieClipAnimFactory.set_textureDigits = function(pDigits) {
	com_isartdigital_utils_game_factory_MovieClipAnimFactory.digits = "";
	var _g = 0;
	while(_g < pDigits) {
		var i = _g++;
		com_isartdigital_utils_game_factory_MovieClipAnimFactory.digits += "0";
	}
	return com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits = pDigits;
};
com_isartdigital_utils_game_factory_MovieClipAnimFactory.addTextures = function(pJson) {
	var lFrames = Reflect.field(pJson,"frames");
	if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition == null) com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition = new haxe_ds_StringMap();
	if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.digits == null) com_isartdigital_utils_game_factory_MovieClipAnimFactory.set_textureDigits(com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits);
	var lID;
	var lNum;
	var _g = 0;
	var _g1 = Reflect.fields(lFrames);
	while(_g < _g1.length) {
		var lID1 = _g1[_g];
		++_g;
		lID1 = lID1.split(".")[0];
		lNum = Std.parseInt(HxOverrides.substr(lID1,-1 * com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits,null));
		if(lNum != null) lID1 = HxOverrides.substr(lID1,0,lID1.length - com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits);
		if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.get(lID1) == null) {
			var v;
			if(lNum == null) v = 1; else v = lNum;
			com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.set(lID1,v);
			v;
		} else if(lNum > com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.get(lID1)) {
			com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.set(lID1,lNum);
			lNum;
		}
	}
	if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache == null) com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache = new haxe_ds_StringMap();
};
com_isartdigital_utils_game_factory_MovieClipAnimFactory.clearTextures = function(pJson) {
	var lFrames = Reflect.field(pJson,"frames");
	if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition == null) return;
	var lID;
	var lNum;
	var _g = 0;
	var _g1 = Reflect.fields(lFrames);
	while(_g < _g1.length) {
		var lID1 = _g1[_g];
		++_g;
		lID1 = lID1.split(".")[0];
		lNum = Std.parseInt(HxOverrides.substr(lID1,-1 * com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits,null));
		if(lNum != null) lID1 = HxOverrides.substr(lID1,0,lID1.length - com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits);
		{
			com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.set(lID1,null);
			null;
		}
		{
			com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.set(lID1,null);
			null;
		}
	}
};
com_isartdigital_utils_game_factory_MovieClipAnimFactory.__super__ = com_isartdigital_utils_game_factory_AnimFactory;
com_isartdigital_utils_game_factory_MovieClipAnimFactory.prototype = $extend(com_isartdigital_utils_game_factory_AnimFactory.prototype,{
	create: function(pID) {
		this.anim = new PIXI.extras.MovieClip(this.getTextures(pID));
		return this.anim;
	}
	,update: function(pID) {
		(js_Boot.__cast(this.anim , PIXI.extras.MovieClip)).textures = this.getTextures(pID);
	}
	,setFrame: function(pAutoPlay,pStart) {
		if(pStart == null) pStart = 0;
		if(pAutoPlay == null) pAutoPlay = true;
		var lAnim;
		lAnim = js_Boot.__cast(this.anim , PIXI.extras.MovieClip);
		lAnim.gotoAndStop(pStart);
		if(pAutoPlay) lAnim.play();
	}
	,getTextures: function(pID) {
		if(com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.get(pID) == null) {
			var lFrames = com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesDefinition.get(pID);
			if(lFrames == 1) {
				var v = [PIXI.Texture.fromFrame(pID + ".png")];
				com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.set(pID,v);
				v;
			} else {
				var v1 = [];
				com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.set(pID,v1);
				v1;
				var _g1 = 1;
				var _g = lFrames + 1;
				while(_g1 < _g) {
					var i = _g1++;
					com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.get(pID).push(PIXI.Texture.fromFrame(pID + HxOverrides.substr(com_isartdigital_utils_game_factory_MovieClipAnimFactory.digits + i,-1 * com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits,null) + ".png"));
				}
			}
		}
		return com_isartdigital_utils_game_factory_MovieClipAnimFactory.texturesCache.get(pID);
	}
	,__class__: com_isartdigital_utils_game_factory_MovieClipAnimFactory
});
var com_isartdigital_utils_loader_GameLoader = function() {
	this.soundsList = [];
	this.soundsSpecs = new haxe_ds_StringMap();
	PIXI.loaders.Loader.call(this);
};
$hxClasses["com.isartdigital.utils.loader.GameLoader"] = com_isartdigital_utils_loader_GameLoader;
com_isartdigital_utils_loader_GameLoader.__name__ = ["com","isartdigital","utils","loader","GameLoader"];
com_isartdigital_utils_loader_GameLoader.getContent = function(pFile) {
	var key = com_isartdigital_utils_Config.get_txtsPath() + pFile;
	return com_isartdigital_utils_loader_GameLoader.txtLoaded.get(key);
};
com_isartdigital_utils_loader_GameLoader.__super__ = PIXI.loaders.Loader;
com_isartdigital_utils_loader_GameLoader.prototype = $extend(PIXI.loaders.Loader.prototype,{
	addTxtFile: function(pUrl) {
		var lUrl = com_isartdigital_utils_Config.get_txtsPath() + pUrl;
		this.add(lUrl,null,null,function(pRessource) {
			console.log("is load " + pRessource.name);
		});
	}
	,addAssetFile: function(pUrl) {
		var lUrl = com_isartdigital_utils_Config.get_assetsPath() + pUrl;
		this.add(lUrl);
	}
	,addSoundFile: function(pUrl) {
		var lUrl = com_isartdigital_utils_Config.get_soundsPath() + pUrl;
		this.soundsList.push(lUrl);
		this.add(lUrl);
	}
	,addFontFile: function(pUrl) {
		var lUrl = com_isartdigital_utils_Config.get_fontsPath() + pUrl;
		this.add(lUrl);
	}
	,parseData: function(pResource,pNext) {
		console.log(pResource.url + " loaded");
		if(pResource.url.indexOf(".css") > 0 && !com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) {
			var lData = pResource.data.split(";");
			var lFamilies = [];
			var lReg = new EReg("font-family:\\s?(.*)","");
			var _g1 = 0;
			var _g = lData.length;
			while(_g1 < _g) {
				var i = _g1++;
				if(lReg.match(lData[i])) lFamilies.push(lReg.matched(1));
			}
			var lWebFontConfig = { custom : { families : lFamilies, urls : [com_isartdigital_utils_Config.get_fontsPath() + "fonts.css"]}, active : pNext};
			WebFont.load(lWebFontConfig);
			return;
		}
		if(pResource.isJson) {
			var v = pResource.data;
			com_isartdigital_utils_loader_GameLoader.txtLoaded.set(pResource.url,v);
			v;
			if(HxOverrides.substr(pResource.url,-12,12) == "library.json" && Object.prototype.hasOwnProperty.call(pResource.data,"md5") && Object.prototype.hasOwnProperty.call(pResource.data,"movies") && Object.prototype.hasOwnProperty.call(pResource.data,"textureGroups") && Object.prototype.hasOwnProperty.call(pResource.data,"frameRate")) {
				pixi_loaders_FlumpParser.flumpParser(pResource,pNext);
				return;
			} else if(this.soundsList.length > 0) {
				var lData1;
				var _g11 = 0;
				var _g2 = this.soundsList.length;
				while(_g11 < _g2) {
					var i1 = _g11++;
					if(pResource.url == this.soundsList[i1]) {
						this.soundsList.splice(i1,1);
						lData1 = pResource.data;
						if(com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) {
							if(HxOverrides.indexOf(lData1.extensions,"ogg",0) == -1) throw new js__$Boot_HaxeError("CocoonJs needs ogg sounds. No sound will be played in the application."); else lData1.extensions = ["ogg"];
						}
						var _g3 = 0;
						var _g21 = lData1.extensions.length;
						while(_g3 < _g21) {
							var j = _g3++;
							if(window.Howler.codecs(lData1.extensions[j])) {
								this.addSounds(lData1.fxs,false,lData1.extensions,lData1.extensions[i1]);
								this.addSounds(lData1.musics,true,lData1.extensions,lData1.extensions[i1]);
								break;
							}
						}
						break;
					}
				}
			}
		}
		pNext();
	}
	,addSounds: function(pList,pLoop,pExtensions,pCodec) {
		var lUrl;
		var _g = 0;
		var _g1 = Reflect.fields(pList);
		while(_g < _g1.length) {
			var lID = _g1[_g];
			++_g;
			lUrl = com_isartdigital_utils_Config.get_soundsPath() + lID + "." + pCodec;
			var value = { urls : [lUrl], volume : Reflect.field(pList,lID) / 100, loop : pLoop};
			this.soundsSpecs.set(lID,value);
			this.add(lUrl);
		}
	}
	,load: function(cb) {
		this.after($bind(this,this.parseData));
		this.once("complete",$bind(this,this.onComplete));
		return PIXI.loaders.Loader.prototype.load.call(this);
	}
	,onComplete: function() {
		var $it0 = this.soundsSpecs.keys();
		while( $it0.hasNext() ) {
			var lID = $it0.next();
			com_isartdigital_utils_sounds_SoundManager.addSound(lID,new window.Howl(this.soundsSpecs.get(lID)));
		}
	}
	,__class__: com_isartdigital_utils_loader_GameLoader
});
var com_isartdigital_utils_sounds_SoundManager = function() {
};
$hxClasses["com.isartdigital.utils.sounds.SoundManager"] = com_isartdigital_utils_sounds_SoundManager;
com_isartdigital_utils_sounds_SoundManager.__name__ = ["com","isartdigital","utils","sounds","SoundManager"];
com_isartdigital_utils_sounds_SoundManager.addSound = function(pName,pSound) {
	if(com_isartdigital_utils_sounds_SoundManager.list == null) com_isartdigital_utils_sounds_SoundManager.list = new haxe_ds_StringMap();
	{
		com_isartdigital_utils_sounds_SoundManager.list.set(pName,pSound);
		pSound;
	}
};
com_isartdigital_utils_sounds_SoundManager.getSound = function(pName) {
	return com_isartdigital_utils_sounds_SoundManager.list.get(pName);
};
com_isartdigital_utils_sounds_SoundManager.prototype = {
	__class__: com_isartdigital_utils_sounds_SoundManager
};
var com_isartdigital_utils_system_DeviceCapabilities = function() { };
$hxClasses["com.isartdigital.utils.system.DeviceCapabilities"] = com_isartdigital_utils_system_DeviceCapabilities;
com_isartdigital_utils_system_DeviceCapabilities.__name__ = ["com","isartdigital","utils","system","DeviceCapabilities"];
com_isartdigital_utils_system_DeviceCapabilities.get_height = function() {
	return window.innerHeight;
};
com_isartdigital_utils_system_DeviceCapabilities.get_width = function() {
	return window.innerWidth;
};
com_isartdigital_utils_system_DeviceCapabilities.get_system = function() {
	if(new EReg("IEMobile","i").match(window.navigator.userAgent)) return "IEMobile"; else if(new EReg("iPhone|iPad|iPod","i").match(window.navigator.userAgent)) return "iOS"; else if(new EReg("BlackBerry","i").match(window.navigator.userAgent)) return "BlackBerry"; else if(new EReg("PlayBook","i").match(window.navigator.userAgent)) return "BlackBerry PlayBook"; else if(new EReg("Android","i").match(window.navigator.userAgent)) return "Android"; else return "Desktop";
};
com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS = function() {
	return window.navigator.isCocoonJS;
};
com_isartdigital_utils_system_DeviceCapabilities.displayFullScreenButton = function() {
	if(com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) return;
	if(!new EReg("(iPad|iPhone|iPod)","g").match(window.navigator.userAgent) && !new EReg("MSIE","i").match(window.navigator.userAgent)) {
		window.document.onfullscreenchange = com_isartdigital_utils_system_DeviceCapabilities.onChangeFullScreen;
		window.document.onwebkitfullscreenchange = com_isartdigital_utils_system_DeviceCapabilities.onChangeFullScreen;
		window.document.onmozfullscreenchange = com_isartdigital_utils_system_DeviceCapabilities.onChangeFullScreen;
		window.document.onmsfullscreenchange = com_isartdigital_utils_system_DeviceCapabilities.onChangeFullScreen;
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton = new Image();
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.position = "absolute";
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.right = "0px";
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.top = "0px";
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.cursor = "pointer";
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.width = Std["int"](com_isartdigital_utils_system_DeviceCapabilities.getSizeFactor() * 0.075);
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.height = Std["int"](com_isartdigital_utils_system_DeviceCapabilities.getSizeFactor() * 0.075);
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.onclick = com_isartdigital_utils_system_DeviceCapabilities.enterFullscreen;
		com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.src = com_isartdigital_utils_Config.get_assetsPath() + "fullscreen.png";
		window.document.body.appendChild(com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton);
	}
};
com_isartdigital_utils_system_DeviceCapabilities.enterFullscreen = function(pEvent) {
	var lDocElm = window.document.documentElement;
	if($bind(lDocElm,lDocElm.requestFullscreen) != null) lDocElm.requestFullscreen(); else if(lDocElm.mozRequestFullScreen != null) lDocElm.mozRequestFullScreen(); else if(lDocElm.webkitRequestFullScreen != null) lDocElm.webkitRequestFullScreen(); else if(lDocElm.msRequestFullscreen != null) lDocElm.msRequestFullscreen();
};
com_isartdigital_utils_system_DeviceCapabilities.exitFullscreen = function() {
	if(($_=window.document,$bind($_,$_.exitFullscreen)) != null) window.document.exitFullscreen(); else if(window.document.mozCancelFullScreen != null) window.document.mozCancelFullScreen(); else if(window.document.webkitCancelFullScreen != null) window.document.webkitCancelFullScreen(); else if(window.document.msExitFullscreen) window.document.msExitFullscreen();
};
com_isartdigital_utils_system_DeviceCapabilities.onChangeFullScreen = function(pEvent) {
	if(window.document.fullScreen || (window.document.mozFullScreen || (window.document.webkitIsFullScreen || window.document.msFullscreenElement))) com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.display = "none"; else com_isartdigital_utils_system_DeviceCapabilities.fullScreenButton.style.display = "block";
	pEvent.preventDefault();
};
com_isartdigital_utils_system_DeviceCapabilities.getSizeFactor = function() {
	var lSize = Math.floor(Math.min(window.screen.width,window.screen.height));
	if(com_isartdigital_utils_system_DeviceCapabilities.get_system() == "Desktop") lSize /= 3;
	return lSize;
};
com_isartdigital_utils_system_DeviceCapabilities.getScreenRect = function(pTarget) {
	var lTopLeft = new PIXI.Point(0,0);
	var lBottomRight = new PIXI.Point(_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_width()),_$UInt_UInt_$Impl_$.toFloat(com_isartdigital_utils_system_DeviceCapabilities.get_height()));
	lTopLeft = pTarget.toLocal(lTopLeft);
	lBottomRight = pTarget.toLocal(lBottomRight);
	return new PIXI.Rectangle(lTopLeft.x,lTopLeft.y,lBottomRight.x - lTopLeft.x,lBottomRight.y - lTopLeft.y);
};
com_isartdigital_utils_system_DeviceCapabilities.scaleViewport = function() {
	if(com_isartdigital_utils_system_DeviceCapabilities.get_system() == "IEMobile") return;
	com_isartdigital_utils_system_DeviceCapabilities.screenRatio = window.devicePixelRatio;
	if(!com_isartdigital_utils_system_DeviceCapabilities.get_isCocoonJS()) window.document.write("<meta name=\"viewport\" content=\"initial-scale=" + Math.round(100 / com_isartdigital_utils_system_DeviceCapabilities.screenRatio) / 100 + ", user-scalable=no, minimal-ui\">");
};
com_isartdigital_utils_system_DeviceCapabilities.init = function(pHd,pMd,pLd) {
	if(pLd == null) pLd = 0.25;
	if(pMd == null) pMd = 0.5;
	if(pHd == null) pHd = 1;
	{
		com_isartdigital_utils_system_DeviceCapabilities.texturesRatios.set("hd",pHd);
		pHd;
	}
	{
		com_isartdigital_utils_system_DeviceCapabilities.texturesRatios.set("md",pMd);
		pMd;
	}
	{
		com_isartdigital_utils_system_DeviceCapabilities.texturesRatios.set("ld",pLd);
		pLd;
	}
	if(com_isartdigital_utils_Config.get_data().texture != null && com_isartdigital_utils_Config.get_data().texture != "") com_isartdigital_utils_system_DeviceCapabilities.textureType = com_isartdigital_utils_Config.get_data().texture; else {
		var lRatio = Math.min(window.screen.width * com_isartdigital_utils_system_DeviceCapabilities.screenRatio / com_isartdigital_utils_game_GameStage.getInstance().get_safeZone().width,window.screen.height * com_isartdigital_utils_system_DeviceCapabilities.screenRatio / com_isartdigital_utils_game_GameStage.getInstance().get_safeZone().height);
		if(lRatio <= 0.25) com_isartdigital_utils_system_DeviceCapabilities.textureType = "ld"; else if(lRatio <= 0.5) com_isartdigital_utils_system_DeviceCapabilities.textureType = "md"; else com_isartdigital_utils_system_DeviceCapabilities.textureType = "hd";
	}
	com_isartdigital_utils_system_DeviceCapabilities.textureRatio = com_isartdigital_utils_system_DeviceCapabilities.texturesRatios.get(com_isartdigital_utils_system_DeviceCapabilities.textureType);
};
var com_isartdigital_utils_ui_Keyboard = function() {
};
$hxClasses["com.isartdigital.utils.ui.Keyboard"] = com_isartdigital_utils_ui_Keyboard;
com_isartdigital_utils_ui_Keyboard.__name__ = ["com","isartdigital","utils","ui","Keyboard"];
com_isartdigital_utils_ui_Keyboard.prototype = {
	__class__: com_isartdigital_utils_ui_Keyboard
};
var com_isartdigital_utils_ui_UIAsset = function(pAssetName) {
	com_isartdigital_utils_game_StateGraphic.call(this);
	this.assetName = pAssetName;
	this.factory = new com_isartdigital_utils_game_factory_FlumpSpriteAnimFactory();
	this.setState(this.DEFAULT_STATE);
};
$hxClasses["com.isartdigital.utils.ui.UIAsset"] = com_isartdigital_utils_ui_UIAsset;
com_isartdigital_utils_ui_UIAsset.__name__ = ["com","isartdigital","utils","ui","UIAsset"];
com_isartdigital_utils_ui_UIAsset.__super__ = com_isartdigital_utils_game_StateGraphic;
com_isartdigital_utils_ui_UIAsset.prototype = $extend(com_isartdigital_utils_game_StateGraphic.prototype,{
	__class__: com_isartdigital_utils_ui_UIAsset
});
var com_isartdigital_utils_ui_UIBuilder = function() {
};
$hxClasses["com.isartdigital.utils.ui.UIBuilder"] = com_isartdigital_utils_ui_UIBuilder;
com_isartdigital_utils_ui_UIBuilder.__name__ = ["com","isartdigital","utils","ui","UIBuilder"];
com_isartdigital_utils_ui_UIBuilder.init = function(pFile,pPackage) {
	com_isartdigital_utils_ui_UIBuilder.description = pFile;
	com_isartdigital_utils_ui_UIBuilder.btnPackage = pPackage;
};
com_isartdigital_utils_ui_UIBuilder.build = function(pId) {
	var lData = com_isartdigital_utils_loader_GameLoader.getContent(com_isartdigital_utils_ui_UIBuilder.description);
	var lList = [];
	var lObj;
	var lItem;
	var lUIPos = [];
	var _g = 0;
	var _g1 = lData.movies;
	while(_g < _g1.length) {
		var lMovie = _g1[_g];
		++_g;
		if(lMovie.id == pId) {
			var _g2 = 0;
			var _g3 = lMovie.layers;
			while(_g2 < _g3.length) {
				var lItem1 = _g3[_g2];
				++_g2;
				if(lItem1.name.indexOf("_txt") == lItem1.name.length - "_txt".length) lObj = new com_isartdigital_utils_ui_UIAsset(lItem1.keyframes[0].ref); else if(lItem1.name.indexOf("Button") == lItem1.name.length - "Button".length) lObj = Type.createInstance(Type.resolveClass(com_isartdigital_utils_ui_UIBuilder.btnPackage + "." + lItem1.keyframes[0].ref),[]); else lObj = new com_isartdigital_utils_ui_UIAsset(lItem1.keyframes[0].ref);
				lObj.name = lItem1.keyframes[0].ref;
				if(Object.prototype.hasOwnProperty.call(lItem1.keyframes[0],"loc")) lObj.position.set(lItem1.keyframes[0].loc[0],lItem1.keyframes[0].loc[1]);
				if(Object.prototype.hasOwnProperty.call(lItem1.keyframes[0],"scale")) lObj.scale.set(lItem1.keyframes[0].scale[0],lItem1.keyframes[0].scale[1]);
				if(Object.prototype.hasOwnProperty.call(lItem1.keyframes[0],"pivot")) lObj.pivot.set(lItem1.keyframes[0].pivot[0],lItem1.keyframes[0].pivot[1]);
				if(Object.prototype.hasOwnProperty.call(lItem1.keyframes[0],"skew")) lObj.rotation = lItem1.keyframes[0].skew[0];
				lUIPos.push(com_isartdigital_utils_ui_UIBuilder.getUIPositionable(lObj,(function($this) {
					var $r;
					var key = lItem1.name.split("_")[0];
					$r = com_isartdigital_utils_ui_UIBuilder.uiPos.get(key);
					return $r;
				}(this))));
			}
		}
	}
	return lUIPos;
};
com_isartdigital_utils_ui_UIBuilder.getUIPositionable = function(pObj,pPosition) {
	var lOffset = new PIXI.Point(0,0);
	if(pPosition != "bottom" && pPosition != "bottomLeft" && pPosition != "bottomRight" && pPosition != "fitHeight" && pPosition != "fitScreen" && pPosition != "fitWidth" && pPosition != "left" && pPosition != "right" && pPosition != "top" && pPosition != "topLeft" && pPosition != "topRight") pPosition = ""; else {
		if(pPosition == "top" || pPosition == "topLeft" || pPosition == "topRight" || pPosition == "bottom" || pPosition == "bottomLeft" || pPosition == "bottomRight") lOffset.y = pObj.y;
		if(pPosition == "left" || pPosition == "topLeft" || pPosition == "bottomLeft" || pPosition == "right" || pPosition == "topRight" || pPosition == "bottomRight") lOffset.x = pObj.x;
	}
	return { item : pObj, align : pPosition, offsetX : lOffset.x, offsetY : lOffset.y, update : true};
};
com_isartdigital_utils_ui_UIBuilder.prototype = {
	__class__: com_isartdigital_utils_ui_UIBuilder
};
var com_isartdigital_utils_ui_UIPosition = function() {
};
$hxClasses["com.isartdigital.utils.ui.UIPosition"] = com_isartdigital_utils_ui_UIPosition;
com_isartdigital_utils_ui_UIPosition.__name__ = ["com","isartdigital","utils","ui","UIPosition"];
com_isartdigital_utils_ui_UIPosition.setPosition = function(pTarget,pPosition,pOffsetX,pOffsetY) {
	if(pOffsetY == null) pOffsetY = 0;
	if(pOffsetX == null) pOffsetX = 0;
	var lScreen = com_isartdigital_utils_system_DeviceCapabilities.getScreenRect(pTarget.parent);
	var lTopLeft = new PIXI.Point(lScreen.x,lScreen.y);
	var lBottomRight = new PIXI.Point(lScreen.x + lScreen.width,lScreen.y + lScreen.height);
	if(pPosition == "top" || pPosition == "topLeft" || pPosition == "topRight") pTarget.y = lTopLeft.y + pOffsetY;
	if(pPosition == "bottom" || pPosition == "bottomLeft" || pPosition == "bottomRight") pTarget.y = lBottomRight.y - pOffsetY;
	if(pPosition == "left" || pPosition == "topLeft" || pPosition == "bottomLeft") pTarget.x = lTopLeft.x + pOffsetX;
	if(pPosition == "right" || pPosition == "topRight" || pPosition == "bottomRight") pTarget.x = lBottomRight.x - pOffsetX;
	if(pPosition == "fitWidth" || pPosition == "fitScreen") {
		pTarget.x = lTopLeft.x;
		pTarget.width = lBottomRight.x - lTopLeft.x;
	}
	if(pPosition == "fitHeight" || pPosition == "fitScreen") {
		pTarget.y = lTopLeft.y;
		pTarget.height = lBottomRight.y - lTopLeft.y;
	}
};
com_isartdigital_utils_ui_UIPosition.prototype = {
	__class__: com_isartdigital_utils_ui_UIPosition
};
var flump_DisplayObjectKey = function(symbolId) {
	this.symbolId = symbolId;
};
$hxClasses["flump.DisplayObjectKey"] = flump_DisplayObjectKey;
flump_DisplayObjectKey.__name__ = ["flump","DisplayObjectKey"];
flump_DisplayObjectKey.prototype = {
	__class__: flump_DisplayObjectKey
};
var flump_IFlumpMovie = function() { };
$hxClasses["flump.IFlumpMovie"] = flump_IFlumpMovie;
flump_IFlumpMovie.__name__ = ["flump","IFlumpMovie"];
flump_IFlumpMovie.prototype = {
	__class__: flump_IFlumpMovie
};
var flump_MoviePlayer = function(symbol,movie) {
	this.position = 0.0;
	this.fullyGenerated = false;
	this.dirty = false;
	this.labelsToFire = [];
	this.childPlayers = new haxe_ds_ObjectMap();
	this.createdChildren = new haxe_ds_ObjectMap();
	this.currentChildrenKey = new haxe_ds_ObjectMap();
	this.STATE_STOPPED = "stopped";
	this.STATE_LOOPING = "looping";
	this.STATE_PLAYING = "playing";
	this.independantControl = false;
	this.independantTimeline = true;
	this.advanced = 0.0;
	this.previousElapsed = 0.0;
	this.elapsed = 0.0;
	this.symbol = symbol;
	this.movie = movie;
	var _g = 0;
	var _g1 = symbol.layers;
	while(_g < _g1.length) {
		var layer = _g1[_g];
		++_g;
		movie.createLayer(layer);
	}
	this.state = this.STATE_LOOPING;
	this.advanceTime(0);
};
$hxClasses["flump.MoviePlayer"] = flump_MoviePlayer;
flump_MoviePlayer.__name__ = ["flump","MoviePlayer"];
flump_MoviePlayer.prototype = {
	getDisplayKey: function(layerId,keyframeIndex) {
		if(keyframeIndex == null) keyframeIndex = 0;
		var layer = this.symbol.getLayer(layerId);
		if(layer == null) throw new js__$Boot_HaxeError("Layer " + layerId + " does not exist.");
		var keyframe = layer.getKeyframeForFrame(keyframeIndex);
		if(keyframe == null) throw new js__$Boot_HaxeError("Keyframe does not exist at index " + Std.string(_$UInt_UInt_$Impl_$.toFloat(keyframeIndex)));
		this.createChildIfNessessary(keyframe);
		return keyframe.displayKey;
	}
	,reset: function() {
		this.elapsed = 0;
		this.previousElapsed = 0;
	}
	,get_position: function() {
		return (this.elapsed % this.symbol.duration + this.symbol.duration) % this.symbol.duration;
	}
	,get_totalFrames: function() {
		return this.symbol.totalFrames;
	}
	,play: function() {
		this.setState(this.STATE_PLAYING);
		return this;
	}
	,loop: function() {
		this.setState(this.STATE_LOOPING);
		return this;
	}
	,stop: function() {
		this.setState(this.STATE_STOPPED);
		return this;
	}
	,goToLabel: function(label) {
		if(!this.labelExists(label)) throw new js__$Boot_HaxeError("Symbol " + this.symbol.name + " does not have label " + label + ".");
		this.set_currentFrame(this.getLabelFrame(label));
		return this;
	}
	,goToFrame: function(frame) {
		this.set_currentFrame(frame);
		return this;
	}
	,goToPosition: function(time) {
		this.elapsed = time;
		this.previousElapsed = time;
		this.clearLabels();
		this.fireLabels();
		return this;
	}
	,get_playing: function() {
		return this.state == this.STATE_PLAYING;
	}
	,get_looping: function() {
		return this.state == this.STATE_LOOPING;
	}
	,get_stopped: function() {
		return this.state == this.STATE_STOPPED;
	}
	,getLabelFrame: function(label) {
		if(!this.labelExists(label)) throw new js__$Boot_HaxeError("Symbol " + this.symbol.name + " does not have label " + label + ".");
		return this.symbol.labels.get(label).keyframe.index;
	}
	,get_currentFrame: function() {
		return Std["int"](this.get_position() / this.symbol.library.frameTime);
	}
	,set_currentFrame: function(value) {
		this.goToPosition(this.symbol.library.frameTime * value);
		return value;
	}
	,labelExists: function(label) {
		return this.symbol.labels.exists("label");
	}
	,advanceTime: function(ms) {
		if(this.state != this.STATE_STOPPED) {
			this.elapsed += ms;
			while(this.elapsed < 0) {
				this.elapsed += this.symbol.duration;
				this.previousElapsed += this.symbol.duration;
			}
		}
		this.advanced += ms;
		if(this.state != this.STATE_STOPPED) this.fireLabels();
		this.render();
	}
	,clearLabels: function() {
		while(this.labelsToFire.length > 0) this.labelsToFire.pop();
	}
	,fireLabels: function() {
		if(this.symbol.firstLabel == null) return;
		if(this.previousElapsed > this.elapsed) return;
		var label;
		if(this.previousElapsed <= this.elapsed) label = this.symbol.firstLabel; else label = this.symbol.lastLabel;
		var checking = true;
		while(checking) if(label.keyframe.time > this.previousElapsed % this.symbol.duration) checking = false; else if(_$UInt_UInt_$Impl_$.gte(label.keyframe.index,label.next.keyframe.index)) {
			checking = false;
			label = label.next;
		} else label = label.next;
		var firstChecked = label;
		while(label != null) {
			var checkFrom = this.previousElapsed % this.symbol.duration;
			var checkTo = this.elapsed % this.symbol.duration;
			if(label.keyframe.insideRangeStart(checkFrom,checkTo)) this.labelsToFire.push(label);
			label = label.next;
			if(label == firstChecked) label = null;
		}
		while(this.labelsToFire.length > 0) this.movie.labelPassed(this.labelsToFire.shift());
	}
	,render: function() {
		if(this.state == this.STATE_PLAYING) {
			if(this.get_position() < 0) {
				this.elapsed = 0;
				this.stop();
				this.movie.onAnimationComplete();
			} else if(this.get_position() >= this.symbol.duration - this.symbol.library.frameTime) {
				this.elapsed = this.symbol.duration - this.symbol.library.frameTime;
				this.stop();
				this.movie.onAnimationComplete();
			}
		}
		while(this.get_position() < 0) this.position += this.symbol.duration;
		var _g = 0;
		var _g1 = this.symbol.layers;
		while(_g < _g1.length) {
			var layer = _g1[_g];
			++_g;
			var keyframe = layer.getKeyframeForTime(this.get_position());
			if(keyframe.isEmpty == true) this.removeChildIfNessessary(keyframe); else if(keyframe.isEmpty == false) {
				var interped = this.getInterpolation(keyframe,this.get_position());
				var next = keyframe.next;
				if(next.isEmpty) next = keyframe;
				this.movie.renderFrame(keyframe,keyframe.location.x + (next.location.x - keyframe.location.x) * interped,keyframe.location.y + (next.location.y - keyframe.location.y) * interped,keyframe.scale.x + (next.scale.x - keyframe.scale.x) * interped,keyframe.scale.y + (next.scale.y - keyframe.scale.y) * interped,keyframe.skew.x + (next.skew.x - keyframe.skew.x) * interped,keyframe.skew.y + (next.skew.y - keyframe.skew.y) * interped);
				if(this.currentChildrenKey.h[layer.__id__] != keyframe.displayKey) {
					this.createChildIfNessessary(keyframe);
					this.removeChildIfNessessary(keyframe);
					this.addChildIfNessessary(keyframe);
				}
				if(js_Boot.__instanceof(keyframe.symbol,flump_library_MovieSymbol)) {
					var childMovie = this.movie.getChildPlayer(keyframe);
					if(childMovie.independantTimeline) {
						childMovie.advanceTime(this.advanced);
						childMovie.render();
					} else {
						childMovie.elapsed = this.get_position();
						childMovie.render();
					}
				}
			}
		}
		this.advanced = 0;
		this.previousElapsed = this.elapsed;
	}
	,createChildIfNessessary: function(keyframe) {
		if(keyframe.isEmpty) return;
		if(this.createdChildren.h.__keys__[keyframe.displayKey.__id__] != null == false) {
			this.movie.createFlumpChild(keyframe.displayKey);
			{
				this.createdChildren.set(keyframe.displayKey,true);
				true;
			}
		}
	}
	,removeChildIfNessessary: function(keyframe) {
		if(this.currentChildrenKey.h.__keys__[keyframe.layer.__id__] != null) {
			this.movie.removeFlumpChild(keyframe.layer,keyframe.displayKey);
			this.currentChildrenKey.remove(keyframe.layer);
		}
	}
	,addChildIfNessessary: function(keyframe) {
		if(keyframe.isEmpty) return;
		var v = keyframe.displayKey;
		this.currentChildrenKey.set(keyframe.layer,v);
		v;
		this.movie.addFlumpChild(keyframe.layer,keyframe.displayKey);
	}
	,setState: function(state) {
		this.state = state;
		var _g = 0;
		var _g1 = this.symbol.layers;
		while(_g < _g1.length) {
			var layer = _g1[_g];
			++_g;
			var keyframe = layer.getKeyframeForTime(this.get_position());
			this.createChildIfNessessary(keyframe);
			if(js_Boot.__instanceof(keyframe.symbol,flump_library_MovieSymbol)) {
				var childMovie = this.movie.getChildPlayer(keyframe);
				if(childMovie.independantControl == false) childMovie.setState(state);
			}
		}
		this.advanceTime(0);
	}
	,timeForLabel: function(label) {
		return this.symbol.labels.get(label).keyframe.time;
	}
	,getInterpolation: function(keyframe,time) {
		if(keyframe.tweened == false) return 0.0;
		var interped = (time - keyframe.time) / keyframe.duration;
		var ease = keyframe.ease;
		if(ease != 0) {
			var t;
			if(ease < 0) {
				var inv = 1 - interped;
				t = 1 - inv * inv;
				ease = -ease;
			} else t = interped * interped;
			interped = ease * t + (1 - ease) * interped;
		}
		return interped;
	}
	,__class__: flump_MoviePlayer
};
var flump_json__$FlumpJSON_FlumpPointSpec_$Impl_$ = {};
$hxClasses["flump.json._FlumpJSON.FlumpPointSpec_Impl_"] = flump_json__$FlumpJSON_FlumpPointSpec_$Impl_$;
flump_json__$FlumpJSON_FlumpPointSpec_$Impl_$.__name__ = ["flump","json","_FlumpJSON","FlumpPointSpec_Impl_"];
flump_json__$FlumpJSON_FlumpPointSpec_$Impl_$.get_x = function(this1) {
	return this1[0];
};
flump_json__$FlumpJSON_FlumpPointSpec_$Impl_$.get_y = function(this1) {
	return this1[1];
};
var flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$ = {};
$hxClasses["flump.json._FlumpJSON.FlumpRectSpec_Impl_"] = flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$;
flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$.__name__ = ["flump","json","_FlumpJSON","FlumpRectSpec_Impl_"];
flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$.get_x = function(this1) {
	return this1[0];
};
flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$.get_y = function(this1) {
	return this1[1];
};
flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$.get_width = function(this1) {
	return this1[2];
};
flump_json__$FlumpJSON_FlumpRectSpec_$Impl_$.get_height = function(this1) {
	return this1[3];
};
var flump_library_FlumpLibrary = function() {
	this.atlases = [];
	this.sprites = new haxe_ds_StringMap();
	this.movies = new haxe_ds_StringMap();
};
$hxClasses["flump.library.FlumpLibrary"] = flump_library_FlumpLibrary;
flump_library_FlumpLibrary.__name__ = ["flump","library","FlumpLibrary"];
flump_library_FlumpLibrary.create = function(flumpData) {
	var lib = flumpData;
	var spriteSymbols = new haxe_ds_StringMap();
	var movieSymbols = new haxe_ds_StringMap();
	var flumpLibrary = new flump_library_FlumpLibrary();
	flumpLibrary.sprites = spriteSymbols;
	flumpLibrary.movies = movieSymbols;
	flumpLibrary.framerate = _$UInt_UInt_$Impl_$.toFloat(lib.frameRate);
	flumpLibrary.frameTime = 1000 / flumpLibrary.framerate;
	flumpLibrary.md5 = lib.md5;
	var atlasSpecs = [];
	var _g = 0;
	var _g1 = lib.textureGroups;
	while(_g < _g1.length) {
		var textureGroup = _g1[_g];
		++_g;
		var _g2 = 0;
		var _g3 = textureGroup.atlases;
		while(_g2 < _g3.length) {
			var atlas = _g3[_g2];
			++_g2;
			flumpLibrary.atlases.push(atlas);
			atlasSpecs.push(atlas);
		}
	}
	var _g4 = 0;
	while(_g4 < atlasSpecs.length) {
		var spec = atlasSpecs[_g4];
		++_g4;
		var _g11 = 0;
		var _g21 = spec.textures;
		while(_g11 < _g21.length) {
			var textureSpec = _g21[_g11];
			++_g11;
			var frame = new flump_library_Rectangle(textureSpec.rect[0],textureSpec.rect[1],textureSpec.rect[2],textureSpec.rect[3]);
			var origin = new flump_library_Point(textureSpec.origin[0],textureSpec.origin[1]);
			origin.x = origin.x / frame.width;
			origin.y = origin.y / frame.height;
			var symbol = new flump_library_SpriteSymbol();
			symbol.name = textureSpec.symbol;
			symbol.origin = origin;
			symbol.texture = textureSpec.symbol;
			{
				spriteSymbols.set(symbol.name,symbol);
				symbol;
			}
		}
	}
	var pendingSymbolAttachments = new haxe_ds_ObjectMap();
	var _g5 = 0;
	var _g12 = lib.movies;
	while(_g5 < _g12.length) {
		var movieSpec = _g12[_g5];
		++_g5;
		var symbol1 = new flump_library_MovieSymbol();
		symbol1.name = movieSpec.id;
		symbol1.library = flumpLibrary;
		var _g22 = 0;
		var _g31 = movieSpec.layers;
		while(_g22 < _g31.length) {
			var layerSpec = _g31[_g22];
			++_g22;
			var layer1 = new flump_library_Layer(layerSpec.name);
			layer1.movie = symbol1;
			var layerDuration = 0;
			var previousKeyframe = null;
			var _g41 = 0;
			var _g51 = layerSpec.keyframes;
			while(_g41 < _g51.length) {
				var keyframeSpec = _g51[_g41];
				++_g41;
				var keyframe1 = new flump_library_Keyframe();
				keyframe1.prev = previousKeyframe;
				if(previousKeyframe != null) previousKeyframe.next = keyframe1;
				keyframe1.layer = layer1;
				keyframe1.numFrames = keyframeSpec.duration;
				keyframe1.duration = _$UInt_UInt_$Impl_$.toFloat(keyframeSpec.duration) * flumpLibrary.frameTime;
				keyframe1.index = keyframeSpec.index;
				var time = _$UInt_UInt_$Impl_$.toFloat(keyframe1.index) * flumpLibrary.frameTime;
				time *= 10;
				time = Math.floor(time);
				time /= 10;
				keyframe1.time = time;
				if(keyframeSpec.ref == null) keyframe1.isEmpty = true; else {
					keyframe1.isEmpty = false;
					keyframe1.symbolId = keyframeSpec.ref;
					if(keyframeSpec.pivot == null) keyframe1.pivot = new flump_library_Point(0,0); else keyframe1.pivot = new flump_library_Point(keyframeSpec.pivot[0],keyframeSpec.pivot[1]);
					if(keyframeSpec.loc == null) keyframe1.location = new flump_library_Point(0,0); else keyframe1.location = new flump_library_Point(keyframeSpec.loc[0],keyframeSpec.loc[1]);
					if(keyframeSpec.tweened == false) keyframe1.tweened = false; else keyframe1.tweened = true;
					keyframe1.symbol = null;
					if(keyframeSpec.scale == null) keyframe1.scale = new flump_library_Point(1,1); else keyframe1.scale = new flump_library_Point(keyframeSpec.scale[0],keyframeSpec.scale[1]);
					if(keyframeSpec.skew == null) keyframe1.skew = new flump_library_Point(0,0); else keyframe1.skew = new flump_library_Point(keyframeSpec.skew[0],keyframeSpec.skew[1]);
					if(keyframeSpec.ease == null) keyframe1.ease = 0; else keyframe1.ease = keyframeSpec.ease;
				}
				if(layer1.keyframes.length == 0) layer1.firstKeyframe = keyframe1;
				if(keyframeSpec.label != null) {
					keyframe1.label = new flump_library_Label();
					keyframe1.label.keyframe = keyframe1;
					keyframe1.label.name = keyframeSpec.label;
					symbol1.labels.set(keyframe1.label.name,keyframe1.label);
				}
				if(keyframe1.time + keyframe1.duration > layer1.duration) layerDuration = keyframe1.time + keyframe1.duration;
				var v = keyframeSpec.ref;
				pendingSymbolAttachments.set(keyframe1,v);
				v;
				layer1.keyframes.push(keyframe1);
				previousKeyframe = keyframe1;
			}
			layer1.lastKeyframe = layer1.keyframes[layer1.keyframes.length - 1];
			layer1.keyframes[0].prev = layer1.lastKeyframe;
			layer1.lastKeyframe.next = layer1.keyframes[0];
			symbol1.layers.push(layer1);
			var allAreEmpty = Lambda.foreach(layer1.keyframes,(function() {
				return function(keyframe) {
					return keyframe.isEmpty;
				};
			})());
			if(allAreEmpty) {
			} else {
				var _g42 = 0;
				var _g52 = layer1.keyframes;
				while(_g42 < _g52.length) {
					var keyframe2 = [_g52[_g42]];
					++_g42;
					var hasNonEmptySibling = Lambda.exists(layer1.keyframes,(function(keyframe2) {
						return function(checkedKeyframe1) {
							return checkedKeyframe1.isEmpty == false && checkedKeyframe1 != keyframe2[0];
						};
					})(keyframe2));
					if(hasNonEmptySibling) {
						var checked1 = keyframe2[0].prev;
						while(checked1.isEmpty) checked1 = checked1.prev;
						keyframe2[0].prevNonEmptyKeyframe = checked1;
						checked1 = keyframe2[0].next;
						while(checked1.isEmpty) checked1 = checked1.next;
						keyframe2[0].nextNonEmptyKeyframe = checked1;
					} else {
						keyframe2[0].prevNonEmptyKeyframe = keyframe2[0];
						keyframe2[0].nextNonEmptyKeyframe = keyframe2[0];
					}
				}
				var firstNonEmpty = Lambda.find(layer1.keyframes,(function() {
					return function(checkedKeyframe) {
						return checkedKeyframe.isEmpty == false;
					};
				})());
				if(firstNonEmpty != null) firstNonEmpty.displayKey = new flump_DisplayObjectKey(firstNonEmpty.symbolId);
				var checked = firstNonEmpty.nextNonEmptyKeyframe;
				while(checked != firstNonEmpty) {
					if(checked.symbolId == checked.prevNonEmptyKeyframe.symbolId) checked.displayKey = checked.prevNonEmptyKeyframe.displayKey; else checked.displayKey = new flump_DisplayObjectKey(checked.symbolId);
					checked = checked.nextNonEmptyKeyframe;
				}
			}
		}
		var getHighestFrameNumber = (function() {
			return function(layer,accum) {
				var layerLength = layer.lastKeyframe.index + layer.lastKeyframe.numFrames;
				if(_$UInt_UInt_$Impl_$.gt(layerLength,accum)) return layerLength; else return accum;
			};
		})();
		symbol1.totalFrames = Lambda.fold(symbol1.layers,getHighestFrameNumber,0);
		symbol1.duration = _$UInt_UInt_$Impl_$.toFloat(symbol1.totalFrames) * flumpLibrary.frameTime;
		var labels = [];
		var _g23 = 0;
		var _g32 = symbol1.layers;
		while(_g23 < _g32.length) {
			var layer2 = _g32[_g23];
			++_g23;
			var _g43 = 0;
			var _g53 = layer2.keyframes;
			while(_g43 < _g53.length) {
				var keyframe3 = _g53[_g43];
				++_g43;
				if(keyframe3.label != null) labels.push(keyframe3.label);
			}
		}
		haxe_ds_ArraySort.sort(labels,flump_library_FlumpLibrary.sortLabel);
		var _g33 = 0;
		var _g24 = labels.length;
		while(_g33 < _g24) {
			var i = _g33++;
			var nextIndex = i + 1;
			if(nextIndex >= labels.length) nextIndex = 0;
			var label = labels[i];
			var nextLabel = labels[nextIndex];
			label.next = nextLabel;
			nextLabel.prev = label;
		}
		symbol1.firstLabel = labels[0];
		symbol1.lastLabel = labels[labels.length - 1];
		{
			movieSymbols.set(symbol1.name,symbol1);
			symbol1;
		}
	}
	var $it0 = pendingSymbolAttachments.keys();
	while( $it0.hasNext() ) {
		var keyframe4 = $it0.next();
		var symbolId = pendingSymbolAttachments.h[keyframe4.__id__];
		if((__map_reserved[symbolId] != null?spriteSymbols.getReserved(symbolId):spriteSymbols.h[symbolId]) != null) keyframe4.symbol = __map_reserved[symbolId] != null?spriteSymbols.getReserved(symbolId):spriteSymbols.h[symbolId]; else keyframe4.symbol = __map_reserved[symbolId] != null?movieSymbols.getReserved(symbolId):movieSymbols.h[symbolId];
	}
	return flumpLibrary;
};
flump_library_FlumpLibrary.sortLabel = function(a,b) {
	if(_$UInt_UInt_$Impl_$.gt(b.keyframe.index,a.keyframe.index)) return -1; else if(_$UInt_UInt_$Impl_$.gt(a.keyframe.index,b.keyframe.index)) return 1;
	return 0;
};
flump_library_FlumpLibrary.prototype = {
	__class__: flump_library_FlumpLibrary
};
var flump_library_Keyframe = function() {
};
$hxClasses["flump.library.Keyframe"] = flump_library_Keyframe;
flump_library_Keyframe.__name__ = ["flump","library","Keyframe"];
flump_library_Keyframe.prototype = {
	timeInside: function(time) {
		return this.time <= time && this.time + this.duration > time;
	}
	,rangeInside: function(from,to) {
		return this.timeInside(from) && this.timeInside(to);
	}
	,rangeIntersect: function(from,to) {
		return this.timeInside(from) || this.timeInside(to);
	}
	,insideRangeStart: function(from,to) {
		if(from == to && to == this.time) return true;
		if(from <= to) return this.time > from && this.time <= to; else return this.time > from || this.time <= to;
	}
	,insideRangeEnd: function(from,to) {
		if(from == to && to == this.time + this.duration) return true;
		if(from > to) return to <= this.time + this.duration && from > this.time + this.duration; else return to <= this.time + this.duration || from > this.time + this.duration;
	}
	,__class__: flump_library_Keyframe
};
var flump_library_Label = function() {
};
$hxClasses["flump.library.Label"] = flump_library_Label;
flump_library_Label.__name__ = ["flump","library","Label"];
flump_library_Label.prototype = {
	__class__: flump_library_Label
};
var flump_library_Layer = function(name) {
	this.keyframes = [];
	this.name = name;
};
$hxClasses["flump.library.Layer"] = flump_library_Layer;
flump_library_Layer.__name__ = ["flump","library","Layer"];
flump_library_Layer.prototype = {
	getKeyframeForFrame: function(index) {
		var _g = 0;
		var _g1 = this.keyframes;
		while(_g < _g1.length) {
			var keyframe = _g1[_g];
			++_g;
			if(keyframe.index == index) return keyframe;
		}
		return null;
	}
	,getKeyframeForTime: function(time) {
		var keyframe = this.lastKeyframe;
		while(keyframe.time > time % this.movie.duration) keyframe = keyframe.prev;
		return keyframe;
	}
	,__class__: flump_library_Layer
};
var flump_library_Symbol = function() {
};
$hxClasses["flump.library.Symbol"] = flump_library_Symbol;
flump_library_Symbol.__name__ = ["flump","library","Symbol"];
flump_library_Symbol.prototype = {
	__class__: flump_library_Symbol
};
var flump_library_MovieSymbol = function() {
	this.labels = new haxe_ds_StringMap();
	this.layers = [];
	flump_library_Symbol.call(this);
};
$hxClasses["flump.library.MovieSymbol"] = flump_library_MovieSymbol;
flump_library_MovieSymbol.__name__ = ["flump","library","MovieSymbol"];
flump_library_MovieSymbol.__super__ = flump_library_Symbol;
flump_library_MovieSymbol.prototype = $extend(flump_library_Symbol.prototype,{
	getLayer: function(name) {
		var _g = 0;
		var _g1 = this.layers;
		while(_g < _g1.length) {
			var layer = _g1[_g];
			++_g;
			if(layer.name == name) return layer;
		}
		return null;
	}
	,debug: function() {
		var largestLayerChars = Lambda.fold(this.layers,function(layer,result) {
			if(layer.name.length > result) return layer.name.length; else return result;
		},0);
		var repeat = function(character,amount) {
			var output = "";
			while(amount > 0) {
				output += character;
				amount--;
			}
			return output;
		};
		var output1 = "asdfsadf\n";
		output1 += repeat(" ",largestLayerChars);
		output1 += "   ";
		var _g1 = 0;
		var _g = this.totalFrames;
		while(_g1 < _g) {
			var i = _g1++;
			if(i % 5 == 0) output1 += i; else if(i % 6 != 0 || i < 10) output1 += " ";
		}
		output1 += "\n";
		output1 += repeat(" ",largestLayerChars);
		output1 += "   ";
		var _g11 = 0;
		var _g2 = this.totalFrames;
		while(_g11 < _g2) {
			var i1 = _g11++;
			if(i1 % 5 == 0) output1 += "▽"; else output1 += " ";
		}
		output1 += "\n";
		var _g12 = 0;
		var _g3 = this.layers.length;
		while(_g12 < _g3) {
			var i2 = _g12++;
			var layer1 = this.layers[i2];
			output1 += layer1.name + repeat(" ",largestLayerChars - layer1.name.length);
			output1 += " : ";
			var _g21 = 0;
			var _g31 = layer1.keyframes;
			while(_g21 < _g31.length) {
				var keyframe = _g31[_g21];
				++_g21;
				if(keyframe.symbolId != null) {
					output1 += "◙";
					if(keyframe.tweened) output1 += repeat("▸",keyframe.numFrames - 1); else output1 += repeat("◉",keyframe.numFrames - 1);
				} else {
					output1 += "○";
					output1 += repeat("◌",keyframe.numFrames - 1);
				}
			}
			output1 += "\n";
		}
		return output1;
	}
	,__class__: flump_library_MovieSymbol
});
var flump_library_Point = function(x,y) {
	this.x = x;
	this.y = y;
};
$hxClasses["flump.library.Point"] = flump_library_Point;
flump_library_Point.__name__ = ["flump","library","Point"];
flump_library_Point.prototype = {
	__class__: flump_library_Point
};
var flump_library_Rectangle = function(x,y,width,height) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
};
$hxClasses["flump.library.Rectangle"] = flump_library_Rectangle;
flump_library_Rectangle.__name__ = ["flump","library","Rectangle"];
flump_library_Rectangle.prototype = {
	__class__: flump_library_Rectangle
};
var flump_library_SpriteSymbol = function() {
	flump_library_Symbol.call(this);
};
$hxClasses["flump.library.SpriteSymbol"] = flump_library_SpriteSymbol;
flump_library_SpriteSymbol.__name__ = ["flump","library","SpriteSymbol"];
flump_library_SpriteSymbol.__super__ = flump_library_Symbol;
flump_library_SpriteSymbol.prototype = $extend(flump_library_Symbol.prototype,{
	__class__: flump_library_SpriteSymbol
});
var haxe_IMap = function() { };
$hxClasses["haxe.IMap"] = haxe_IMap;
haxe_IMap.__name__ = ["haxe","IMap"];
haxe_IMap.prototype = {
	__class__: haxe_IMap
};
var haxe_Timer = function(time_ms) {
	var me = this;
	this.id = setInterval(function() {
		me.run();
	},time_ms);
};
$hxClasses["haxe.Timer"] = haxe_Timer;
haxe_Timer.__name__ = ["haxe","Timer"];
haxe_Timer.delay = function(f,time_ms) {
	var t = new haxe_Timer(time_ms);
	t.run = function() {
		t.stop();
		f();
	};
	return t;
};
haxe_Timer.prototype = {
	stop: function() {
		if(this.id == null) return;
		clearInterval(this.id);
		this.id = null;
	}
	,run: function() {
	}
	,__class__: haxe_Timer
};
var haxe_ds_ArraySort = function() { };
$hxClasses["haxe.ds.ArraySort"] = haxe_ds_ArraySort;
haxe_ds_ArraySort.__name__ = ["haxe","ds","ArraySort"];
haxe_ds_ArraySort.sort = function(a,cmp) {
	haxe_ds_ArraySort.rec(a,cmp,0,a.length);
};
haxe_ds_ArraySort.rec = function(a,cmp,from,to) {
	var middle = from + to >> 1;
	if(to - from < 12) {
		if(to <= from) return;
		var _g = from + 1;
		while(_g < to) {
			var i = _g++;
			var j = i;
			while(j > from) {
				if(cmp(a[j],a[j - 1]) < 0) haxe_ds_ArraySort.swap(a,j - 1,j); else break;
				j--;
			}
		}
		return;
	}
	haxe_ds_ArraySort.rec(a,cmp,from,middle);
	haxe_ds_ArraySort.rec(a,cmp,middle,to);
	haxe_ds_ArraySort.doMerge(a,cmp,from,middle,to,middle - from,to - middle);
};
haxe_ds_ArraySort.doMerge = function(a,cmp,from,pivot,to,len1,len2) {
	var first_cut;
	var second_cut;
	var len11;
	var len22;
	var new_mid;
	if(len1 == 0 || len2 == 0) return;
	if(len1 + len2 == 2) {
		if(cmp(a[pivot],a[from]) < 0) haxe_ds_ArraySort.swap(a,pivot,from);
		return;
	}
	if(len1 > len2) {
		len11 = len1 >> 1;
		first_cut = from + len11;
		second_cut = haxe_ds_ArraySort.lower(a,cmp,pivot,to,first_cut);
		len22 = second_cut - pivot;
	} else {
		len22 = len2 >> 1;
		second_cut = pivot + len22;
		first_cut = haxe_ds_ArraySort.upper(a,cmp,from,pivot,second_cut);
		len11 = first_cut - from;
	}
	haxe_ds_ArraySort.rotate(a,cmp,first_cut,pivot,second_cut);
	new_mid = first_cut + len22;
	haxe_ds_ArraySort.doMerge(a,cmp,from,first_cut,new_mid,len11,len22);
	haxe_ds_ArraySort.doMerge(a,cmp,new_mid,second_cut,to,len1 - len11,len2 - len22);
};
haxe_ds_ArraySort.rotate = function(a,cmp,from,mid,to) {
	var n;
	if(from == mid || mid == to) return;
	n = haxe_ds_ArraySort.gcd(to - from,mid - from);
	while(n-- != 0) {
		var val = a[from + n];
		var shift = mid - from;
		var p1 = from + n;
		var p2 = from + n + shift;
		while(p2 != from + n) {
			a[p1] = a[p2];
			p1 = p2;
			if(to - p2 > shift) p2 += shift; else p2 = from + (shift - (to - p2));
		}
		a[p1] = val;
	}
};
haxe_ds_ArraySort.gcd = function(m,n) {
	while(n != 0) {
		var t = m % n;
		m = n;
		n = t;
	}
	return m;
};
haxe_ds_ArraySort.upper = function(a,cmp,from,to,val) {
	var len = to - from;
	var half;
	var mid;
	while(len > 0) {
		half = len >> 1;
		mid = from + half;
		if(cmp(a[val],a[mid]) < 0) len = half; else {
			from = mid + 1;
			len = len - half - 1;
		}
	}
	return from;
};
haxe_ds_ArraySort.lower = function(a,cmp,from,to,val) {
	var len = to - from;
	var half;
	var mid;
	while(len > 0) {
		half = len >> 1;
		mid = from + half;
		if(cmp(a[mid],a[val]) < 0) {
			from = mid + 1;
			len = len - half - 1;
		} else len = half;
	}
	return from;
};
haxe_ds_ArraySort.swap = function(a,i,j) {
	var tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
};
var haxe_ds_ObjectMap = function() {
	this.h = { };
	this.h.__keys__ = { };
};
$hxClasses["haxe.ds.ObjectMap"] = haxe_ds_ObjectMap;
haxe_ds_ObjectMap.__name__ = ["haxe","ds","ObjectMap"];
haxe_ds_ObjectMap.__interfaces__ = [haxe_IMap];
haxe_ds_ObjectMap.prototype = {
	set: function(key,value) {
		var id = key.__id__ || (key.__id__ = ++haxe_ds_ObjectMap.count);
		this.h[id] = value;
		this.h.__keys__[id] = key;
	}
	,remove: function(key) {
		var id = key.__id__;
		if(this.h.__keys__[id] == null) return false;
		delete(this.h[id]);
		delete(this.h.__keys__[id]);
		return true;
	}
	,keys: function() {
		var a = [];
		for( var key in this.h.__keys__ ) {
		if(this.h.hasOwnProperty(key)) a.push(this.h.__keys__[key]);
		}
		return HxOverrides.iter(a);
	}
	,iterator: function() {
		return { ref : this.h, it : this.keys(), hasNext : function() {
			return this.it.hasNext();
		}, next : function() {
			var i = this.it.next();
			return this.ref[i.__id__];
		}};
	}
	,__class__: haxe_ds_ObjectMap
};
var haxe_ds__$StringMap_StringMapIterator = function(map,keys) {
	this.map = map;
	this.keys = keys;
	this.index = 0;
	this.count = keys.length;
};
$hxClasses["haxe.ds._StringMap.StringMapIterator"] = haxe_ds__$StringMap_StringMapIterator;
haxe_ds__$StringMap_StringMapIterator.__name__ = ["haxe","ds","_StringMap","StringMapIterator"];
haxe_ds__$StringMap_StringMapIterator.prototype = {
	hasNext: function() {
		return this.index < this.count;
	}
	,next: function() {
		return this.map.get(this.keys[this.index++]);
	}
	,__class__: haxe_ds__$StringMap_StringMapIterator
};
var haxe_ds_StringMap = function() {
	this.h = { };
};
$hxClasses["haxe.ds.StringMap"] = haxe_ds_StringMap;
haxe_ds_StringMap.__name__ = ["haxe","ds","StringMap"];
haxe_ds_StringMap.__interfaces__ = [haxe_IMap];
haxe_ds_StringMap.prototype = {
	set: function(key,value) {
		if(__map_reserved[key] != null) this.setReserved(key,value); else this.h[key] = value;
	}
	,get: function(key) {
		if(__map_reserved[key] != null) return this.getReserved(key);
		return this.h[key];
	}
	,exists: function(key) {
		if(__map_reserved[key] != null) return this.existsReserved(key);
		return this.h.hasOwnProperty(key);
	}
	,setReserved: function(key,value) {
		if(this.rh == null) this.rh = { };
		this.rh["$" + key] = value;
	}
	,getReserved: function(key) {
		if(this.rh == null) return null; else return this.rh["$" + key];
	}
	,existsReserved: function(key) {
		if(this.rh == null) return false;
		return this.rh.hasOwnProperty("$" + key);
	}
	,remove: function(key) {
		if(__map_reserved[key] != null) {
			key = "$" + key;
			if(this.rh == null || !this.rh.hasOwnProperty(key)) return false;
			delete(this.rh[key]);
			return true;
		} else {
			if(!this.h.hasOwnProperty(key)) return false;
			delete(this.h[key]);
			return true;
		}
	}
	,keys: function() {
		var _this = this.arrayKeys();
		return HxOverrides.iter(_this);
	}
	,arrayKeys: function() {
		var out = [];
		for( var key in this.h ) {
		if(this.h.hasOwnProperty(key)) out.push(key);
		}
		if(this.rh != null) {
			for( var key in this.rh ) {
			if(key.charCodeAt(0) == 36) out.push(key.substr(1));
			}
		}
		return out;
	}
	,iterator: function() {
		return new haxe_ds__$StringMap_StringMapIterator(this,this.arrayKeys());
	}
	,__class__: haxe_ds_StringMap
};
var js__$Boot_HaxeError = function(val) {
	Error.call(this);
	this.val = val;
	this.message = String(val);
	if(Error.captureStackTrace) Error.captureStackTrace(this,js__$Boot_HaxeError);
};
$hxClasses["js._Boot.HaxeError"] = js__$Boot_HaxeError;
js__$Boot_HaxeError.__name__ = ["js","_Boot","HaxeError"];
js__$Boot_HaxeError.__super__ = Error;
js__$Boot_HaxeError.prototype = $extend(Error.prototype,{
	__class__: js__$Boot_HaxeError
});
var js_Boot = function() { };
$hxClasses["js.Boot"] = js_Boot;
js_Boot.__name__ = ["js","Boot"];
js_Boot.getClass = function(o) {
	if((o instanceof Array) && o.__enum__ == null) return Array; else {
		var cl = o.__class__;
		if(cl != null) return cl;
		var name = js_Boot.__nativeClassName(o);
		if(name != null) return js_Boot.__resolveNativeClass(name);
		return null;
	}
};
js_Boot.__string_rec = function(o,s) {
	if(o == null) return "null";
	if(s.length >= 5) return "<...>";
	var t = typeof(o);
	if(t == "function" && (o.__name__ || o.__ename__)) t = "object";
	switch(t) {
	case "object":
		if(o instanceof Array) {
			if(o.__enum__) {
				if(o.length == 2) return o[0];
				var str2 = o[0] + "(";
				s += "\t";
				var _g1 = 2;
				var _g = o.length;
				while(_g1 < _g) {
					var i1 = _g1++;
					if(i1 != 2) str2 += "," + js_Boot.__string_rec(o[i1],s); else str2 += js_Boot.__string_rec(o[i1],s);
				}
				return str2 + ")";
			}
			var l = o.length;
			var i;
			var str1 = "[";
			s += "\t";
			var _g2 = 0;
			while(_g2 < l) {
				var i2 = _g2++;
				str1 += (i2 > 0?",":"") + js_Boot.__string_rec(o[i2],s);
			}
			str1 += "]";
			return str1;
		}
		var tostr;
		try {
			tostr = o.toString;
		} catch( e ) {
			if (e instanceof js__$Boot_HaxeError) e = e.val;
			return "???";
		}
		if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
			var s2 = o.toString();
			if(s2 != "[object Object]") return s2;
		}
		var k = null;
		var str = "{\n";
		s += "\t";
		var hasp = o.hasOwnProperty != null;
		for( var k in o ) {
		if(hasp && !o.hasOwnProperty(k)) {
			continue;
		}
		if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
			continue;
		}
		if(str.length != 2) str += ", \n";
		str += s + k + " : " + js_Boot.__string_rec(o[k],s);
		}
		s = s.substring(1);
		str += "\n" + s + "}";
		return str;
	case "function":
		return "<function>";
	case "string":
		return o;
	default:
		return String(o);
	}
};
js_Boot.__interfLoop = function(cc,cl) {
	if(cc == null) return false;
	if(cc == cl) return true;
	var intf = cc.__interfaces__;
	if(intf != null) {
		var _g1 = 0;
		var _g = intf.length;
		while(_g1 < _g) {
			var i = _g1++;
			var i1 = intf[i];
			if(i1 == cl || js_Boot.__interfLoop(i1,cl)) return true;
		}
	}
	return js_Boot.__interfLoop(cc.__super__,cl);
};
js_Boot.__instanceof = function(o,cl) {
	if(cl == null) return false;
	switch(cl) {
	case Int:
		return (o|0) === o;
	case Float:
		return typeof(o) == "number";
	case Bool:
		return typeof(o) == "boolean";
	case String:
		return typeof(o) == "string";
	case Array:
		return (o instanceof Array) && o.__enum__ == null;
	case Dynamic:
		return true;
	default:
		if(o != null) {
			if(typeof(cl) == "function") {
				if(o instanceof cl) return true;
				if(js_Boot.__interfLoop(js_Boot.getClass(o),cl)) return true;
			} else if(typeof(cl) == "object" && js_Boot.__isNativeObj(cl)) {
				if(o instanceof cl) return true;
			}
		} else return false;
		if(cl == Class && o.__name__ != null) return true;
		if(cl == Enum && o.__ename__ != null) return true;
		return o.__enum__ == cl;
	}
};
js_Boot.__cast = function(o,t) {
	if(js_Boot.__instanceof(o,t)) return o; else throw new js__$Boot_HaxeError("Cannot cast " + Std.string(o) + " to " + Std.string(t));
};
js_Boot.__nativeClassName = function(o) {
	var name = js_Boot.__toStr.call(o).slice(8,-1);
	if(name == "Object" || name == "Function" || name == "Math" || name == "JSON") return null;
	return name;
};
js_Boot.__isNativeObj = function(o) {
	return js_Boot.__nativeClassName(o) != null;
};
js_Boot.__resolveNativeClass = function(name) {
	return (Function("return typeof " + name + " != \"undefined\" ? " + name + " : null"))();
};
var pixi_display_FlumpMovie = function(symbolId,resourceId) {
	this.animationSpeed = 1.0;
	this.ticker = PIXI.ticker.shared;
	this.displaying = new haxe_ds_ObjectMap();
	this.movieChildren = new haxe_ds_ObjectMap();
	this.layerLookup = new haxe_ds_StringMap();
	this.layers = new haxe_ds_ObjectMap();
	PIXI.Container.call(this);
	this.resourceId = resourceId;
	if(resourceId == null) {
		this.resource = pixi_display_FlumpResource.getResourceForMovie(symbolId);
		if(this.resource == null) throw new js__$Boot_HaxeError("Flump movie does not exist: " + symbolId);
	} else {
		this.resource = pixi_display_FlumpResource.get(resourceId);
		if(this.resource == null) throw new js__$Boot_HaxeError("Flump resource does not exist: " + resourceId);
	}
	this.symbol = this.resource.library.movies.get(symbolId);
	this.player = new flump_MoviePlayer(this.symbol,this);
	this.set_loop(true);
	this.master = true;
	this.once("added",$bind(this,this.onAdded));
};
$hxClasses["pixi.display.FlumpMovie"] = pixi_display_FlumpMovie;
pixi_display_FlumpMovie.__name__ = ["pixi","display","FlumpMovie"];
pixi_display_FlumpMovie.__interfaces__ = [flump_IFlumpMovie];
pixi_display_FlumpMovie.__super__ = PIXI.Container;
pixi_display_FlumpMovie.prototype = $extend(PIXI.Container.prototype,{
	disableAsMaster: function() {
		this.master = false;
		this.off("added",$bind(this,this.onAdded));
	}
	,getLayer: function(layerId) {
		if(this.layerLookup.exists(layerId) == false) throw new js__$Boot_HaxeError("Layer " + layerId + "does not exist");
		return this.layerLookup.get(layerId);
	}
	,getChildDisplayObject: function(layerId,keyframeIndex) {
		if(keyframeIndex == null) keyframeIndex = 0;
		var key = this.player.getDisplayKey(layerId,keyframeIndex);
		return this.movieChildren.h[key.__id__];
	}
	,getChildMovie: function(layerId,keyframeIndex) {
		if(keyframeIndex == null) keyframeIndex = 0;
		var child = this.getChildDisplayObject(layerId,keyframeIndex);
		if(js_Boot.__instanceof(child,pixi_display_FlumpMovie) == false) throw new js__$Boot_HaxeError("Child on layer " + layerId + " at keyframeIndex " + Std.string(_$UInt_UInt_$Impl_$.toFloat(keyframeIndex)) + " is not of type FlumpMovie!");
		return child;
	}
	,get_symbolId: function() {
		return this.symbol.name;
	}
	,set_loop: function(value) {
		if(value && this.player.get_playing()) this.player.loop(); else if(value == false && this.player.get_looping()) this.player.play();
		return this.loop = value;
	}
	,set_onComplete: function(value) {
		return this.onComplete = value;
	}
	,set_currentFrame: function(value) {
		this.player.set_currentFrame(value);
		return value;
	}
	,get_currentFrame: function() {
		return this.player.get_currentFrame();
	}
	,get_playing: function() {
		return this.player.get_playing() || this.player.get_looping();
	}
	,get_independantTimeline: function() {
		return this.player.independantTimeline;
	}
	,set_independantTimeline: function(value) {
		this.player.independantTimeline = value;
		return value;
	}
	,get_independantControl: function() {
		return this.player.independantControl;
	}
	,set_independantControl: function(value) {
		this.player.independantControl = value;
		return value;
	}
	,get_totalFrames: function() {
		return this.player.get_totalFrames();
	}
	,stop: function() {
		this.player.stop();
	}
	,play: function() {
		if(this.loop) this.player.loop(); else this.player.play();
	}
	,gotoAndStop: function(frameNumber) {
		if(!this.loop) {
			if(_$UInt_UInt_$Impl_$.gt(frameNumber,(function($this) {
				var $r;
				var a = $this.player.get_totalFrames();
				$r = a - 1;
				return $r;
			}(this)))) {
				var a1 = this.player.get_totalFrames();
				frameNumber = a1 - 1;
			} else if(frameNumber < 0) frameNumber = 0;
		}
		this.player.goToFrame(frameNumber).stop();
	}
	,gotoAndPlay: function(frameNumber) {
		if(!this.loop) {
			if(_$UInt_UInt_$Impl_$.gt(frameNumber,(function($this) {
				var $r;
				var a = $this.player.get_totalFrames();
				$r = a - 1;
				return $r;
			}(this)))) {
				var a1 = this.player.get_totalFrames();
				frameNumber = a1 - 1;
			} else if(frameNumber < 0) frameNumber = 0;
		}
		if(this.loop) this.player.goToFrame(frameNumber).loop(); else this.player.goToFrame(frameNumber).play();
	}
	,getLabelFrame: function(label) {
		return this.player.getLabelFrame(label);
	}
	,tick: function() {
		this.player.advanceTime(this.ticker.elapsedMS * this.animationSpeed);
	}
	,onAdded: function(to) {
		this.once("removed",$bind(this,this.onRemoved));
		this.ticker.add($bind(this,this.tick));
	}
	,onRemoved: function(from) {
		this.once("added",$bind(this,this.onAdded));
		this.ticker.remove($bind(this,this.tick));
	}
	,createLayer: function(layer) {
		var v = new pixi_display_PixiLayer();
		this.layers.set(layer,v);
		v;
		var v1 = this.layers.h[layer.__id__];
		this.layerLookup.set(layer.name,v1);
		v1;
		this.addChild(this.layers.h[layer.__id__]);
	}
	,getChildPlayer: function(keyframe) {
		var movie = this.movieChildren.h[keyframe.displayKey.__id__];
		return movie.player;
	}
	,createFlumpChild: function(displayKey) {
		var v = this.resource.createDisplayObject(displayKey.symbolId);
		this.movieChildren.set(displayKey,v);
		v;
	}
	,removeFlumpChild: function(layer,displayKey) {
		var layer1 = this.layers.h[layer.__id__];
		layer1.removeChildren();
	}
	,addFlumpChild: function(layer,displayKey) {
		var layer1 = this.layers.h[layer.__id__];
		layer1.addChild(this.movieChildren.h[displayKey.__id__]);
	}
	,onAnimationComplete: function() {
		if(this.onComplete != null) this.onComplete();
	}
	,renderFrame: function(keyframe,x,y,scaleX,scaleY,skewX,skewY) {
		var layer = this.layers.h[keyframe.layer.__id__];
		layer.x = x;
		layer.y = y;
		layer.scale.x = scaleX;
		layer.scale.y = scaleY;
		layer.skew.x = skewX;
		layer.skew.y = skewY;
		layer.pivot.x = keyframe.pivot.x;
		layer.pivot.y = keyframe.pivot.y;
	}
	,labelPassed: function(label) {
		this.emit("labelPassed",label.name);
	}
	,destroy: function() {
		this.stop();
		this.set_onComplete(null);
		var $it0 = this.layers.iterator();
		while( $it0.hasNext() ) {
			var layer = $it0.next();
			layer.removeChildren();
		}
		this.symbol = null;
		this.player = null;
		PIXI.Container.prototype.destroy.call(this,true);
	}
	,__class__: pixi_display_FlumpMovie
});
var pixi_display_FlumpResource = function(library,textures,resourceId) {
	this.library = library;
	this.textures = textures;
	this.resourceId = resourceId;
};
$hxClasses["pixi.display.FlumpResource"] = pixi_display_FlumpResource;
pixi_display_FlumpResource.__name__ = ["pixi","display","FlumpResource"];
pixi_display_FlumpResource.exists = function(resourceName) {
	return pixi_display_FlumpResource.resources.exists(resourceName);
};
pixi_display_FlumpResource.destroy = function(resourceName) {
	if(pixi_display_FlumpResource.resources.exists(resourceName) == false) throw new js__$Boot_HaxeError("Cannot destroy FlumpResource: " + resourceName + " as it does not exist.");
	var resource = pixi_display_FlumpResource.resources.get(resourceName);
	var $it0 = resource.textures.iterator();
	while( $it0.hasNext() ) {
		var texture = $it0.next();
		texture.destroy();
	}
	resource.library = null;
	pixi_display_FlumpResource.resources.remove(resourceName);
};
pixi_display_FlumpResource.flumpParser = function(resource,next) {
	if(resource.data == null || resource.isJson == false) return;
	if(!resource.data.hasField("md5") || !resource.data.hasField("movies") || !resource.data.hasField("textureGroups") || !resource.data.hasField("frameRate")) return;
	var lib = flump_library_FlumpLibrary.create(resource.data);
	var textures = new haxe_ds_StringMap();
	var atlasLoader = new PIXI.loaders.Loader();
	atlasLoader.baseUrl = new EReg("/(.[^/]*)$","i").replace(resource.url,"");
	var _g = 0;
	var _g1 = lib.atlases;
	while(_g < _g1.length) {
		var atlasSpec = [_g1[_g]];
		++_g;
		atlasLoader.add(atlasSpec[0].file,null,(function(atlasSpec) {
			return function(atlasResource) {
				var atlasTexture = new PIXI.BaseTexture(atlasResource.data);
				var _g2 = 0;
				var _g3 = atlasSpec[0].textures;
				while(_g2 < _g3.length) {
					var textureSpec = _g3[_g2];
					++_g2;
					var frame = new PIXI.Rectangle(textureSpec.rect[0],textureSpec.rect[1],textureSpec.rect[2],textureSpec.rect[3]);
					var origin = new flump_library_Point(textureSpec.origin[0],textureSpec.origin[1]);
					origin.x = origin.x / frame.width;
					origin.y = origin.y / frame.height;
					var v = new PIXI.Texture(atlasTexture,frame);
					textures.set(textureSpec.symbol,v);
					v;
				}
			};
		})(atlasSpec));
	}
	atlasLoader.once("complete",function(loader) {
		var flumpResource = new pixi_display_FlumpResource(lib,textures,resource.name);
		if(resource.name != null) {
			pixi_display_FlumpResource.resources.set(resource.name,flumpResource);
			flumpResource;
		}
		resource.data = flumpResource;
		next();
	});
	atlasLoader.load();
};
pixi_display_FlumpResource.get = function(resourceName) {
	if(!pixi_display_FlumpResource.resources.exists(resourceName)) throw new js__$Boot_HaxeError("Flump resource: " + resourceName + " does not exist.");
	return pixi_display_FlumpResource.resources.get(resourceName);
};
pixi_display_FlumpResource.getResourceForMovie = function(symbolId) {
	var $it0 = pixi_display_FlumpResource.resources.iterator();
	while( $it0.hasNext() ) {
		var resource = $it0.next();
		if(resource.library.movies.exists(symbolId)) return resource;
	}
	throw new js__$Boot_HaxeError("Movie: " + symbolId + " does not exists in any loaded flump resources.");
};
pixi_display_FlumpResource.getResourceForSprite = function(symbolId) {
	var $it0 = pixi_display_FlumpResource.resources.iterator();
	while( $it0.hasNext() ) {
		var resource = $it0.next();
		if(resource.library.sprites.exists(symbolId)) return resource;
	}
	throw new js__$Boot_HaxeError("Sprite: " + symbolId + " does not exists in any loaded flump resources.");
};
pixi_display_FlumpResource.prototype = {
	createMovie: function(id) {
		var movie = new pixi_display_FlumpMovie(id,this.resourceId);
		movie.disableAsMaster();
		return movie;
	}
	,createSprite: function(id) {
		return new pixi_display_FlumpSprite(id,this.resourceId);
	}
	,createDisplayObject: function(id) {
		if(this.library.movies.exists(id)) return this.createMovie(id); else return this.createSprite(id);
	}
	,__class__: pixi_display_FlumpResource
};
var pixi_display_FlumpSprite = function(symbolId,resourceId) {
	this.symbolId = symbolId;
	this.resourceId = resourceId;
	var resource;
	if(resourceId != null) {
		resource = pixi_display_FlumpResource.get(resourceId);
		if(resource == null) throw new js__$Boot_HaxeError("Library: " + resourceId + "does has not been loaded.");
	} else resource = pixi_display_FlumpResource.getResourceForSprite(symbolId);
	var symbol = resource.library.sprites.get(symbolId);
	var texture = resource.textures.get(symbol.texture);
	PIXI.Sprite.call(this,texture);
	this.pivot.x = symbol.origin.x;
	this.pivot.y = symbol.origin.y;
};
$hxClasses["pixi.display.FlumpSprite"] = pixi_display_FlumpSprite;
pixi_display_FlumpSprite.__name__ = ["pixi","display","FlumpSprite"];
pixi_display_FlumpSprite.__super__ = PIXI.Sprite;
pixi_display_FlumpSprite.prototype = $extend(PIXI.Sprite.prototype,{
	__class__: pixi_display_FlumpSprite
});
var pixi_display_PixiLayer = function() {
	this.skew = new PIXI.Point();
	PIXI.Container.call(this);
};
$hxClasses["pixi.display.PixiLayer"] = pixi_display_PixiLayer;
pixi_display_PixiLayer.__name__ = ["pixi","display","PixiLayer"];
pixi_display_PixiLayer.__super__ = PIXI.Container;
pixi_display_PixiLayer.prototype = $extend(PIXI.Container.prototype,{
	updateTransform: function() {
		
            if (!this.visible)
            {
                return;
            }
		
             // create some matrix refs for easy access
            var pt = this.parent.worldTransform;
            var wt = this.worldTransform;

            // temporary matrix variables
            var a, b, c, d, tx, ty,
                rotY = this.rotation + this.skew.y,
                rotX = this.rotation + this.skew.x;
        ;
		
            // so if rotation is between 0 then we can simplify the multiplication process..
            if (rotY % (Math.PI*2) || rotX % (Math.PI*2))
            {
                // check to see if the rotation is the same as the previous render. This means we only need to use sin and cos when rotation actually changes
                if (rotX !== this._cachedRotX || rotY !== this._cachedRotY)
                {
                    // cache new values
                    this._cachedRotX = rotX;
                    this._cachedRotY = rotY;

                    // recalculate expensive ops
                    this._crA = Math.cos(rotY);
                    this._srB = Math.sin(rotY);

                    this._srC = Math.sin(-rotX);
                    this._crD = Math.cos(rotX);
                }

                // get the matrix values of the displayobject based on its transform properties..
                a  = this._crA * this.scale.x;
                b  = this._srB * this.scale.x;
                c  = this._srC * this.scale.y;
                d  = this._crD * this.scale.y;
                tx = this.position.x;
                ty = this.position.y;

                // check for pivot.. not often used so geared towards that fact!
                //if (this.pivot.x || this.pivot.y)
                //{
                    tx -= this.pivot.x * a + this.pivot.y * c;
                    ty -= this.pivot.x * b + this.pivot.y * d;
                //}

                // concat the parent matrix with the objects transform.
                wt.a  = a  * pt.a + b  * pt.c;
                wt.b  = a  * pt.b + b  * pt.d;
                wt.c  = c  * pt.a + d  * pt.c;
                wt.d  = c  * pt.b + d  * pt.d;
                wt.tx = tx * pt.a + ty * pt.c + pt.tx;
                wt.ty = tx * pt.b + ty * pt.d + pt.ty;
            }
            else
            {
                // lets do the fast version as we know there is no rotation..
                a  = this.scale.x;
                d  = this.scale.y;

                tx = this.position.x - this.pivot.x * a;
                ty = this.position.y - this.pivot.y * d;

                wt.a  = a  * pt.a;
                wt.b  = a  * pt.b;
                wt.c  = d  * pt.c;
                wt.d  = d  * pt.d;
                wt.tx = tx * pt.a + ty * pt.c + pt.tx;
                wt.ty = tx * pt.b + ty * pt.d + pt.ty;
            }
        ;
		

            // multiply the alphas..
            this.worldAlpha = this.alpha * this.parent.worldAlpha;

            // reset the bounds each time this is called!
            this._currentBounds = null;
        ;
		
            for (var i = 0, j = this.children.length; i < j; ++i)
            {
                this.children[i].updateTransform();
            }   
        ;
	}
	,__class__: pixi_display_PixiLayer
});
var pixi_loaders_FlumpParser = function() { };
$hxClasses["pixi.loaders.FlumpParser"] = pixi_loaders_FlumpParser;
pixi_loaders_FlumpParser.__name__ = ["pixi","loaders","FlumpParser"];
pixi_loaders_FlumpParser.flumpParser = function(resource,next) {
	if(resource.data == null || resource.isJson == false) return;
	if(!Object.prototype.hasOwnProperty.call(resource.data,"md5") || !Object.prototype.hasOwnProperty.call(resource.data,"movies") || !Object.prototype.hasOwnProperty.call(resource.data,"textureGroups") || !Object.prototype.hasOwnProperty.call(resource.data,"frameRate")) return;
	var lib = flump_library_FlumpLibrary.create(resource.data);
	var textures = new haxe_ds_StringMap();
	var atlasLoader = new PIXI.loaders.Loader();
	atlasLoader.baseUrl = new EReg("/(.[^/]*)$","i").replace(resource.url,"");
	var _g = 0;
	var _g1 = lib.atlases;
	while(_g < _g1.length) {
		var atlasSpec = [_g1[_g]];
		++_g;
		atlasLoader.add(atlasSpec[0].file,null,(function(atlasSpec) {
			return function(atlasResource) {
				var atlasTexture = new PIXI.BaseTexture(atlasResource.data);
				var _g2 = 0;
				var _g3 = atlasSpec[0].textures;
				while(_g2 < _g3.length) {
					var textureSpec = _g3[_g2];
					++_g2;
					var frame = new PIXI.Rectangle(textureSpec.rect[0],textureSpec.rect[1],textureSpec.rect[2],textureSpec.rect[3]);
					var origin = new PIXI.Point(textureSpec.origin[0],textureSpec.origin[1]);
					origin.x = origin.x / frame.width;
					origin.y = origin.y / frame.height;
					var v = new PIXI.Texture(atlasTexture,frame);
					textures.set(textureSpec.symbol,v);
					v;
				}
			};
		})(atlasSpec));
	}
	atlasLoader.once("complete",function(loader) {
		var flumpResource = new pixi_display_FlumpResource(lib,textures,resource.name);
		if(resource.name != null) {
			pixi_display_FlumpResource.resources.set(resource.name,flumpResource);
			flumpResource;
		}
		resource.data = flumpResource;
		next();
	});
	atlasLoader.load();
};
function $iterator(o) { if( o instanceof Array ) return function() { return HxOverrides.iter(o); }; return typeof(o.iterator) == 'function' ? $bind(o,o.iterator) : o.iterator; }
var $_, $fid = 0;
function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $fid++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = function(){ return f.method.apply(f.scope, arguments); }; f.scope = o; f.method = m; o.hx__closures__[m.__id__] = f; } return f; }
if(Array.prototype.indexOf) HxOverrides.indexOf = function(a,o,i) {
	return Array.prototype.indexOf.call(a,o,i);
};
$hxClasses.Math = Math;
String.prototype.__class__ = $hxClasses.String = String;
String.__name__ = ["String"];
$hxClasses.Array = Array;
Array.__name__ = ["Array"];
var Int = $hxClasses.Int = { __name__ : ["Int"]};
var Dynamic = $hxClasses.Dynamic = { __name__ : ["Dynamic"]};
var Float = $hxClasses.Float = Number;
Float.__name__ = ["Float"];
var Bool = Boolean;
Bool.__ename__ = ["Bool"];
var Class = $hxClasses.Class = { __name__ : ["Class"]};
var Enum = { };
var __map_reserved = {}
com_isartdigital_Main.CONFIG_PATH = "config.json";
com_isartdigital_game_GameManager.MAXLAYER = 2;
com_isartdigital_game_GameManager.levelLayer = 0;
com_isartdigital_game_GameManager.layer = 0;
com_isartdigital_game_LevelManager.TOPICKNUMBER = 3;
com_isartdigital_game_LevelManager.OBJECTINTERVAL = 5000;
com_isartdigital_game_LevelManager.OBJECTINTERVALMIN = 4000;
com_isartdigital_game_LevelManager.DESAPPEARTIMER = 3000;
com_isartdigital_game_LevelManager._PNG = ".png";
com_isartdigital_game_MoveManager.arrayArrow = [];
com_isartdigital_game_MoveManager.arrayDirection = [];
com_isartdigital_game_MoveManager.createArrow = true;
com_isartdigital_game_MoveManager.boxInputZone = new PIXI.Graphics();
com_isartdigital_game_MoveManager.MAXCOMBO = 8;
com_isartdigital_game_MoveManager.combo = 0;
com_isartdigital_utils_game_StateGraphic.animAlpha = 1;
com_isartdigital_utils_game_StateGraphic.boxAlpha = 0;
com_isartdigital_game_sprites_Arrow.speeds = [4,8,10];
com_isartdigital_game_sprites_Arrow.arrowsArray = [];
com_isartdigital_game_sprites_Arrow.firstArrow = false;
com_isartdigital_game_sprites_CheckItem.arrayCheckItem = [];
com_isartdigital_game_sprites_Foule.arrayFoule = [];
com_isartdigital_game_sprites_Foule.nbFrame = 20;
com_isartdigital_game_sprites_Player.IDLE_STATE = "idle";
com_isartdigital_game_sprites_Player.LEFT_STATE = "left";
com_isartdigital_game_sprites_Player.RIGHT_STATE = "right";
com_isartdigital_game_sprites_Player.UP_STATE = "up";
com_isartdigital_game_sprites_Player.DOWN_STATE = "down";
com_isartdigital_game_sprites_Player.speed = 10;
com_isartdigital_utils_ui_Button.UP = 0;
com_isartdigital_utils_ui_Button.OVER = 1;
com_isartdigital_utils_ui_Button.DOWN = 2;
com_isartdigital_ui_popin_Annonce._PNG = ".png";
com_isartdigital_utils_Config._data = { };
com_isartdigital_utils_Debug.QR_SIZE = 0.35;
com_isartdigital_utils_events_EventType.GAME_LOOP = "gameLoop";
com_isartdigital_utils_events_EventType.RESIZE = "resize";
com_isartdigital_utils_events_EventType.ADDED = "added";
com_isartdigital_utils_events_EventType.REMOVED = "removed";
com_isartdigital_utils_events_LoadEventType.COMPLETE = "complete";
com_isartdigital_utils_events_LoadEventType.LOADED = "load";
com_isartdigital_utils_events_LoadEventType.PROGRESS = "progress";
com_isartdigital_utils_events_LoadEventType.ERROR = "error";
com_isartdigital_utils_events_MouseEventType.MOUSE_MOVE = "mousemove";
com_isartdigital_utils_events_MouseEventType.MOUSE_DOWN = "mousedown";
com_isartdigital_utils_events_MouseEventType.MOUSE_OUT = "mouseout";
com_isartdigital_utils_events_MouseEventType.MOUSE_OVER = "mouseover";
com_isartdigital_utils_events_MouseEventType.MOUSE_UP = "mouseup";
com_isartdigital_utils_events_MouseEventType.MOUSE_UP_OUTSIDE = "mouseupoutside";
com_isartdigital_utils_events_MouseEventType.CLICK = "click";
com_isartdigital_utils_events_MouseEventType.RIGHT_DOWN = "rightdown";
com_isartdigital_utils_events_MouseEventType.RIGHT_UP = "rightup";
com_isartdigital_utils_events_MouseEventType.RIGHT_UP_OUTSIDE = "rightupoutside";
com_isartdigital_utils_events_MouseEventType.RIGHT_CLICK = "rightclick";
com_isartdigital_utils_events_TouchEventType.TOUCH_START = "touchstart";
com_isartdigital_utils_events_TouchEventType.TOUCH_MOVE = "touchmove";
com_isartdigital_utils_events_TouchEventType.TOUCH_END = "touchend";
com_isartdigital_utils_events_TouchEventType.TOUCH_END_OUTSIDE = "touchendoutside";
com_isartdigital_utils_events_TouchEventType.TAP = "tap";
com_isartdigital_utils_game_GameStage.SAFE_ZONE_WIDTH = 2048;
com_isartdigital_utils_game_GameStage.SAFE_ZONE_HEIGHT = 1366;
com_isartdigital_utils_game_factory_MovieClipAnimFactory.textureDigits = 4;
com_isartdigital_utils_loader_GameLoader.txtLoaded = new haxe_ds_StringMap();
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_ANDROID = "Android";
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_IOS = "iOS";
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_BLACKBERRY = "BlackBerry";
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_BB_PLAYBOOK = "BlackBerry PlayBook";
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_WINDOWS_MOBILE = "IEMobile";
com_isartdigital_utils_system_DeviceCapabilities.SYSTEM_DESKTOP = "Desktop";
com_isartdigital_utils_system_DeviceCapabilities.ICON_SIZE = 0.075;
com_isartdigital_utils_system_DeviceCapabilities.TEXTURE_NO_SCALE = "";
com_isartdigital_utils_system_DeviceCapabilities.TEXTURE_HD = "hd";
com_isartdigital_utils_system_DeviceCapabilities.TEXTURE_MD = "md";
com_isartdigital_utils_system_DeviceCapabilities.TEXTURE_LD = "ld";
com_isartdigital_utils_system_DeviceCapabilities.texturesRatios = (function($this) {
	var $r;
	var _g = new haxe_ds_StringMap();
	if(__map_reserved.hd != null) _g.setReserved("hd",1); else _g.h["hd"] = 1;
	if(__map_reserved.md != null) _g.setReserved("md",0.5); else _g.h["md"] = 0.5;
	if(__map_reserved.ld != null) _g.setReserved("ld",0.25); else _g.h["ld"] = 0.25;
	$r = _g;
	return $r;
}(this));
com_isartdigital_utils_system_DeviceCapabilities.textureRatio = 1;
com_isartdigital_utils_system_DeviceCapabilities.textureType = "";
com_isartdigital_utils_system_DeviceCapabilities.screenRatio = 1;
com_isartdigital_utils_ui_Keyboard.A = 65;
com_isartdigital_utils_ui_Keyboard.B = 66;
com_isartdigital_utils_ui_Keyboard.C = 67;
com_isartdigital_utils_ui_Keyboard.D = 68;
com_isartdigital_utils_ui_Keyboard.E = 69;
com_isartdigital_utils_ui_Keyboard.F = 70;
com_isartdigital_utils_ui_Keyboard.G = 71;
com_isartdigital_utils_ui_Keyboard.H = 72;
com_isartdigital_utils_ui_Keyboard.I = 73;
com_isartdigital_utils_ui_Keyboard.J = 74;
com_isartdigital_utils_ui_Keyboard.K = 75;
com_isartdigital_utils_ui_Keyboard.L = 76;
com_isartdigital_utils_ui_Keyboard.M = 77;
com_isartdigital_utils_ui_Keyboard.N = 78;
com_isartdigital_utils_ui_Keyboard.O = 79;
com_isartdigital_utils_ui_Keyboard.P = 80;
com_isartdigital_utils_ui_Keyboard.Q = 81;
com_isartdigital_utils_ui_Keyboard.R = 82;
com_isartdigital_utils_ui_Keyboard.S = 83;
com_isartdigital_utils_ui_Keyboard.T = 84;
com_isartdigital_utils_ui_Keyboard.U = 85;
com_isartdigital_utils_ui_Keyboard.V = 86;
com_isartdigital_utils_ui_Keyboard.W = 87;
com_isartdigital_utils_ui_Keyboard.X = 88;
com_isartdigital_utils_ui_Keyboard.Y = 89;
com_isartdigital_utils_ui_Keyboard.Z = 90;
com_isartdigital_utils_ui_Keyboard.NUMBER_0 = 48;
com_isartdigital_utils_ui_Keyboard.NUMBER_1 = 49;
com_isartdigital_utils_ui_Keyboard.NUMBER_2 = 50;
com_isartdigital_utils_ui_Keyboard.NUMBER_3 = 51;
com_isartdigital_utils_ui_Keyboard.NUMBER_4 = 52;
com_isartdigital_utils_ui_Keyboard.NUMBER_5 = 53;
com_isartdigital_utils_ui_Keyboard.NUMBER_6 = 54;
com_isartdigital_utils_ui_Keyboard.NUMBER_7 = 55;
com_isartdigital_utils_ui_Keyboard.NUMBER_8 = 56;
com_isartdigital_utils_ui_Keyboard.NUMBER_9 = 57;
com_isartdigital_utils_ui_Keyboard.NUMPAD_0 = 96;
com_isartdigital_utils_ui_Keyboard.NUMPAD_1 = 97;
com_isartdigital_utils_ui_Keyboard.NUMPAD_2 = 98;
com_isartdigital_utils_ui_Keyboard.NUMPAD_3 = 99;
com_isartdigital_utils_ui_Keyboard.NUMPAD_4 = 100;
com_isartdigital_utils_ui_Keyboard.NUMPAD_5 = 101;
com_isartdigital_utils_ui_Keyboard.NUMPAD_6 = 102;
com_isartdigital_utils_ui_Keyboard.NUMPAD_7 = 103;
com_isartdigital_utils_ui_Keyboard.NUMPAD_8 = 104;
com_isartdigital_utils_ui_Keyboard.NUMPAD_9 = 105;
com_isartdigital_utils_ui_Keyboard.NUMPAD_ADD = 107;
com_isartdigital_utils_ui_Keyboard.NUMPAD_DECIMAL = 110;
com_isartdigital_utils_ui_Keyboard.NUMPAD_DIVIDE = 111;
com_isartdigital_utils_ui_Keyboard.NUMPAD_ENTER = 108;
com_isartdigital_utils_ui_Keyboard.NUMPAD_MULTIPLY = 106;
com_isartdigital_utils_ui_Keyboard.NUMPAD_SUBTRACT = 109;
com_isartdigital_utils_ui_Keyboard.F1 = 112;
com_isartdigital_utils_ui_Keyboard.F2 = 113;
com_isartdigital_utils_ui_Keyboard.F3 = 114;
com_isartdigital_utils_ui_Keyboard.F4 = 115;
com_isartdigital_utils_ui_Keyboard.F5 = 116;
com_isartdigital_utils_ui_Keyboard.F6 = 117;
com_isartdigital_utils_ui_Keyboard.F7 = 118;
com_isartdigital_utils_ui_Keyboard.F8 = 119;
com_isartdigital_utils_ui_Keyboard.F9 = 120;
com_isartdigital_utils_ui_Keyboard.F10 = 121;
com_isartdigital_utils_ui_Keyboard.F11 = 122;
com_isartdigital_utils_ui_Keyboard.F12 = 123;
com_isartdigital_utils_ui_Keyboard.F13 = 124;
com_isartdigital_utils_ui_Keyboard.F14 = 125;
com_isartdigital_utils_ui_Keyboard.F15 = 126;
com_isartdigital_utils_ui_Keyboard.LEFT = 37;
com_isartdigital_utils_ui_Keyboard.UP = 38;
com_isartdigital_utils_ui_Keyboard.RIGHT = 39;
com_isartdigital_utils_ui_Keyboard.DOWN = 40;
com_isartdigital_utils_ui_Keyboard.BACKSLASH = 220;
com_isartdigital_utils_ui_Keyboard.BACKSPACE = 8;
com_isartdigital_utils_ui_Keyboard.CAPS_LOCK = 20;
com_isartdigital_utils_ui_Keyboard.COMMA = 188;
com_isartdigital_utils_ui_Keyboard.COMMAND = 15;
com_isartdigital_utils_ui_Keyboard.CONTROL = 17;
com_isartdigital_utils_ui_Keyboard.DELETE = 46;
com_isartdigital_utils_ui_Keyboard.END = 35;
com_isartdigital_utils_ui_Keyboard.ENTER = 13;
com_isartdigital_utils_ui_Keyboard.EQUAL = 187;
com_isartdigital_utils_ui_Keyboard.ESCAPE = 27;
com_isartdigital_utils_ui_Keyboard.HOME = 36;
com_isartdigital_utils_ui_Keyboard.INSERT = 45;
com_isartdigital_utils_ui_Keyboard.LEFTBRACKET = 219;
com_isartdigital_utils_ui_Keyboard.MINUS = 189;
com_isartdigital_utils_ui_Keyboard.PAGE_DOWN = 34;
com_isartdigital_utils_ui_Keyboard.PAGE_UP = 33;
com_isartdigital_utils_ui_Keyboard.PERIOD = 190;
com_isartdigital_utils_ui_Keyboard.QUOTE = 222;
com_isartdigital_utils_ui_Keyboard.RIGHTBRACKET = 221;
com_isartdigital_utils_ui_Keyboard.SEMICOLON = 186;
com_isartdigital_utils_ui_Keyboard.SHIFT = 16;
com_isartdigital_utils_ui_Keyboard.SLASH = 191;
com_isartdigital_utils_ui_Keyboard.SPACE = 32;
com_isartdigital_utils_ui_Keyboard.TAB = 9;
com_isartdigital_utils_ui_Keyboard.MENU = 16777234;
com_isartdigital_utils_ui_Keyboard.SEARCH = 16777247;
com_isartdigital_utils_ui_UIBuilder.TXT_SUFFIX = "_txt";
com_isartdigital_utils_ui_UIBuilder.BTN_SUFFIX = "Button";
com_isartdigital_utils_ui_UIBuilder.uiPos = (function($this) {
	var $r;
	var _g = new haxe_ds_StringMap();
	if(__map_reserved.L != null) _g.setReserved("L","left"); else _g.h["L"] = "left";
	if(__map_reserved.R != null) _g.setReserved("R","right"); else _g.h["R"] = "right";
	if(__map_reserved.T != null) _g.setReserved("T","top"); else _g.h["T"] = "top";
	if(__map_reserved.B != null) _g.setReserved("B","bottom"); else _g.h["B"] = "bottom";
	if(__map_reserved.TL != null) _g.setReserved("TL","topLeft"); else _g.h["TL"] = "topLeft";
	if(__map_reserved.TR != null) _g.setReserved("TR","topRight"); else _g.h["TR"] = "topRight";
	if(__map_reserved.BL != null) _g.setReserved("BL","bottomLeft"); else _g.h["BL"] = "bottomLeft";
	if(__map_reserved.BR != null) _g.setReserved("BR","bottomRight"); else _g.h["BR"] = "bottomRight";
	if(__map_reserved.FW != null) _g.setReserved("FW","fitWidth"); else _g.h["FW"] = "fitWidth";
	if(__map_reserved.FH != null) _g.setReserved("FH","fitHeight"); else _g.h["FH"] = "fitHeight";
	if(__map_reserved.FS != null) _g.setReserved("FS","fitScreen"); else _g.h["FS"] = "fitScreen";
	$r = _g;
	return $r;
}(this));
com_isartdigital_utils_ui_UIPosition.LEFT = "left";
com_isartdigital_utils_ui_UIPosition.RIGHT = "right";
com_isartdigital_utils_ui_UIPosition.TOP = "top";
com_isartdigital_utils_ui_UIPosition.BOTTOM = "bottom";
com_isartdigital_utils_ui_UIPosition.TOP_LEFT = "topLeft";
com_isartdigital_utils_ui_UIPosition.TOP_RIGHT = "topRight";
com_isartdigital_utils_ui_UIPosition.BOTTOM_LEFT = "bottomLeft";
com_isartdigital_utils_ui_UIPosition.BOTTOM_RIGHT = "bottomRight";
com_isartdigital_utils_ui_UIPosition.FIT_WIDTH = "fitWidth";
com_isartdigital_utils_ui_UIPosition.FIT_HEIGHT = "fitHeight";
com_isartdigital_utils_ui_UIPosition.FIT_SCREEN = "fitScreen";
flump_library_Label.LABEL_ENTER = "labelEnter";
flump_library_Label.LABEL_EXIT = "labelExit";
flump_library_Label.LABEL_UPDATE = "labelUpdate";
haxe_ds_ObjectMap.count = 0;
js_Boot.__toStr = {}.toString;
pixi_display_FlumpResource.resources = new haxe_ds_StringMap();
com_isartdigital_Main.main();
})(typeof console != "undefined" ? console : {log:function(){}});

//# sourceMappingURL=Parade.js.map