define("wildFuryAnimation", ["viewBuilderApi", "componentmodelComponentApi", "clientkernelLoaderApi", "uiHelper", "displayEngineApi", "displayEngineUtils", "gameLayoutApi", "wildFuryAnimationPort", "PIXI", "BABYLON", "clientkernelEventbusApi", "clientkernelModulesApi", "wildFuryAnimationDeclaration", "tools", "clientkernelLoggerApi"],
    function(viewBuilderApi, componentmodelComponentApi, clientkernelLoaderApi, uiHelper, displayEngineApi, displayEngineUtils, gameLayoutApi, wildFuryAnimationPort, PIXI, BABYLON, clientkernelEventbusApi, clientkernelModulesApi, wildFuryAnimationDeclaration, tools, clientkernelLoggerApi) {
        "use strict";

        function $iterator(o) {
            if (o instanceof Array) return function() {
                return {
                    cur: 0,
                    arr: o,
                    hasNext: function() {
                        return this.cur < this.arr.length;
                    },
                    next: function() {
                        return this.arr[this.cur++];
                    }
                };
            };
            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;
        };
        var $_;
        var $estr = function() {
            return _hcmn_.js_Boot.__string_rec(this, '');
        };
        if (typeof _List == 'undefined') {
            var _List = {};
        };
        _List.ListIterator = function(head) {
            this.head = head;
            this.val = null;
        };
        _List.ListIterator.__name__ = ["_List", "ListIterator"];
        _List.ListIterator.prototype.head = null;
        _List.ListIterator.prototype.val = null;
        _List.ListIterator.prototype.hasNext = function() {
            return this.head != null;
        };
        _List.ListIterator.prototype.next = function() {
            this.val = this.head[0];
            this.head = this.head[1];
            return this.val;
        };
        _List.ListIterator.prototype.__class__ = _List.ListIterator;
        if (typeof wildFuryAnimation == 'undefined') {
            var wildFuryAnimation = {};
        };
        wildFuryAnimation.Activator = function(context) {};
        wildFuryAnimation.Activator = ck_implements(wildFuryAnimation.Activator, clientkernelModulesApi.IModuleActivator);
        wildFuryAnimation.Activator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        wildFuryAnimation.Activator.__name__ = ["wildFuryAnimation", "Activator"];
        wildFuryAnimation.Activator.prototype.start = function(context) {
            var services = [viewBuilderApi.IViewBuilderFactory, clientkernelLoaderApi.IAssetRegistry, displayEngineApi.IDisplayProvider];
            context.getServiceTracker(services).then(function(context1) {
                wildFuryAnimation.ExternalService.initialize(context1);
                var vbf = context1.getAnyService(viewBuilderApi.IViewBuilderFactory, null);
                wildFuryAnimation.ExternalService.viewBuilderFactory = vbf;
                context1.registerService(new wildFuryAnimation.AnimationFactory(vbf, context1), wildFuryAnimationDeclaration.AnimationDeclaration, null);
            });
        };
        wildFuryAnimation.Activator.prototype.stop = function(context) {};
        wildFuryAnimation.Activator.main = function() {};
        wildFuryAnimation.Activator.prototype.__class__ = wildFuryAnimation.Activator;
        wildFuryAnimation.Animation = function(context, vbf, configId) {
            this.initialized = false;
            this.layoutPayload = null;
            this.vba = null;
            var _g = this;
            this.context = context;
            this.vbf = vbf;
            this.configId = configId;
            this.port = context.getImplementedPort(wildFuryAnimationPort.IAnimationImplementationPort);
            this.layoutPort = context.getUsedPort(gameLayoutApi.IGameLayoutPort);
            this.layoutPort.getUpdateComponentLayout().subscribe($bind(this, this.onUpdateComponentLayout));
            wildFuryAnimation.ExternalService.loadConfig(configId, function(vba) {
                _g.vba = vba;
                _g.initialize();
            });
        };
        wildFuryAnimation.Animation.__name__ = ["wildFuryAnimation", "Animation"];
        wildFuryAnimation.Animation.prototype.view = null;
        wildFuryAnimation.Animation.prototype.configId = null;
        wildFuryAnimation.Animation.prototype.port = null;
        wildFuryAnimation.Animation.prototype.layoutPort = null;
        wildFuryAnimation.Animation.prototype.component = null;
        wildFuryAnimation.Animation.prototype.context = null;
        wildFuryAnimation.Animation.prototype.vba = null;
        wildFuryAnimation.Animation.prototype.vbf = null;
        wildFuryAnimation.Animation.prototype.controller = null;
        wildFuryAnimation.Animation.prototype.layoutPayload = null;
        wildFuryAnimation.Animation.prototype.initialized = null;
        wildFuryAnimation.Animation.prototype.onUpdateComponentLayout = function(e) {
            this.layoutPayload = e.getPayload();
            if (!this.initialized) this.initialize();
            else this.updateLayout();
        };
        wildFuryAnimation.Animation.prototype.initialize = function() {
            if (!this.initialized && this.vba != null && this.layoutPayload != null) {
                this.controller = new wildFuryAnimation.AnimationController(this);
                this.view = this.vbf.createView(this.vba);
                this.registerAllComponents();
                this.controller.init();
                this.updateLayout();
                this.initialized = true;
            }
        };
        wildFuryAnimation.Animation.prototype.updateLayout = function() {
            this.controller.updateLayout(this.layoutPayload);
            this.layoutPort.getComponentLayoutUpdated().publish(this.context.getInstance());
        };
        wildFuryAnimation.Animation.prototype.registerAllComponents = function() {
            var keys;
            var this1 = this.view.getChildComponents();
            keys = this1.keys();
            if (!keys.hasNext()) keys = this.view.storedConfigs.keys();
            while (keys.hasNext()) {
                var compId = keys.next();
                var comp = this.idToComponentEnum(compId);
                if (comp != wildFuryAnimationPort.AnimationComponent.NONE) this.registerComponent(comp);
            }
        };
        wildFuryAnimation.Animation.prototype.idToComponentEnum = function(id) {
            var ind;
            var _this = _hcmn_.Type.getEnumConstructs(wildFuryAnimationPort.AnimationComponent);
            ind = _hcmn_.HxOverrides.indexOf(_this, id, 0);
            if (ind < 0) return wildFuryAnimationPort.AnimationComponent.NONE;
            return _hcmn_.Type.createEnum(wildFuryAnimationPort.AnimationComponent, id, null);
        };
        wildFuryAnimation.Animation.prototype.registerComponent = function(componentEnum) {
            this.component = null;
            switch (componentEnum[1]) {
                case 0:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.REEL_FRAMES_CONTAINER, wildFuryAnimation.ReelFrameComponent);
                    break;
                case 2:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.REEL_BACKGROUND, wildFuryAnimation.BetPanelAdapatationComponent);
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.REEL_BACKGROUND, wildFuryAnimation.AnimationComponentViewLogic);
                    break;
                case 1:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.PARTICLE_HOLDER, wildFuryAnimation.ParticleComponent);
                    break;
                case 3:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.LOGO, wildFuryAnimation.LogoComponent);
                    break;
                case 4:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.DRAGONS, wildFuryAnimation.DragonsComponent, true);
                    break;
                case 5:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.FLYING_SYMBOLS, wildFuryAnimation.FlyingSymbolsComponent, true);
                    break;
                case 6:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.TENSION, wildFuryAnimation.TensionComponent, true);
                    break;
                case 7:
                    this.registerContainerComponent(wildFuryAnimationPort.AnimationComponent.PROMO, wildFuryAnimation.PromoComponent);
                    break;
                default:
                    return false;
            }
            return true;
        };
        wildFuryAnimation.Animation.prototype.registerContainerComponent = function(componentEnum, componentClass, isAnimated) {
            if (isAnimated == null) isAnimated = false;
            var name = componentEnum[0];
            var container = this.view.getComponentById(name);
            var keys = this.view.storedConfigs.keys();
            if (container == null && keys.hasNext()) {
                var newComponent = this.view.createContainerFromStoredConfig(name);
                this.view.addChildComponent(newComponent, name);
                container = this.view.getComponentById(name);
            }
            if (container != null) {
                var scalefactor = this.vba.getConfiguration().scalefactor;
                this.component = _hcmn_.Type.createInstance(componentClass, [container, scalefactor, isAnimated]);
                wildFuryAnimation.Animation.COMPONENTS.set(componentEnum, this.component);
                if (_hcmn_.js_Boot.__instanceof(this.component, wildFuryAnimation.IViewBuilderSetter))(_hcmn_.js_Boot.__cast(this.component, wildFuryAnimation.IViewBuilderSetter)).setViewBuilder(this.view);
                if (_hcmn_.js_Boot.__instanceof(this.component, wildFuryAnimation.IAnimationPortSetter))(_hcmn_.js_Boot.__cast(this.component, wildFuryAnimation.IAnimationPortSetter)).setAnimationPort(this.port);
            }
        };
        wildFuryAnimation.Animation.prototype.getComponent = function() {
            return this.component;
        };
        wildFuryAnimation.Animation.prototype.isComponent = function(key) {
            return this.getComponent() == this.getComponentByKey(key);
        };
        wildFuryAnimation.Animation.prototype.getComponentByKey = function(key) {
            return wildFuryAnimation.Animation.COMPONENTS.get(key);
        };
        wildFuryAnimation.Animation.prototype.__class__ = wildFuryAnimation.Animation;
        wildFuryAnimation.AnimationController = function(animation) {
            this.isAddedToStage = false;
            this.animation = animation;
        };
        wildFuryAnimation.AnimationController.__name__ = ["wildFuryAnimation", "AnimationController"];
        wildFuryAnimation.AnimationController.prototype.isAddedToStage = null;
        wildFuryAnimation.AnimationController.prototype.animation = null;
        wildFuryAnimation.AnimationController.prototype.init = function() {
            this.animation.port.getAnimationAction().subscribe($bind(this, this.onAnimationAction));
        };
        wildFuryAnimation.AnimationController.prototype.updateLayout = function(layoutPayload) {
            var $it0 = layoutPayload.containers.keys();
            while ($it0.hasNext()) {
                var layerId = $it0.next();
                var layerPayload = layoutPayload.containers.get(layerId);
                var cfg = layerPayload.configuration;
                var stage;
                var this1 = wildFuryAnimation.ExternalService.displayProvider.getStages();
                stage = this1.get(layerPayload.stage);
                var container = this.animation.view.getComponentById(layerId).getDisplayObject();
                if (!this.isAddedToStage) stage.addChild(container);
                container.setX(layerPayload.left);
                container.setY(layerPayload.top);
                var userData = uiHelper.UiHelper.getSimpleHelper().getUserData(container);
                if (layerPayload.width == null) {
                    stage.getCanvas().style.pointerEvents = "none";
                    stage.setWidth((_hcmn_.js_Boot.__cast(stage.getCanvas(), HTMLCanvasElement)).width);
                    stage.setHeight((_hcmn_.js_Boot.__cast(stage.getCanvas(), HTMLCanvasElement)).height);
                    stage.setScaleX(1);
                    stage.setScaleY(1);
                } else {
                    container.setScaleX(layerPayload.width / userData.viewBuilderW);
                    container.setScaleY(layerPayload.height / userData.viewBuilderH);
                }
                container.setZIndex(layerPayload.zIndex);
                this.animation.getComponent().configure(cfg);
            }
            if (!this.isAddedToStage) this.isAddedToStage = true;
        };
        wildFuryAnimation.AnimationController.prototype.onAnimationAction = function(e) {
            var acimationAction = e.getPayload();
            var animationComponent = acimationAction.animationComponent;
            if (this.animation.isComponent(animationComponent)) this.handleAnimationAction(acimationAction);
        };
        wildFuryAnimation.AnimationController.prototype.handleAnimationAction = function(action) {
            var component = this.animation.getComponent();
            component.action(action);
        };
        wildFuryAnimation.AnimationController.prototype.__class__ = wildFuryAnimation.AnimationController;
        wildFuryAnimation.AnimationFactory = function(vbf, context) {
            this.context = context;
            this.vbf = vbf;
        };
        wildFuryAnimation.AnimationFactory = ck_implements(wildFuryAnimation.AnimationFactory, clientkernelModulesApi.IService);
        wildFuryAnimation.AnimationFactory = ck_implements(wildFuryAnimation.AnimationFactory, componentmodelComponentApi.IComponentFactory);
        wildFuryAnimation.AnimationFactory.__interfaces__ = [clientkernelModulesApi.IService, componentmodelComponentApi.IComponentFactory];
        wildFuryAnimation.AnimationFactory.__name__ = ["wildFuryAnimation", "AnimationFactory"];
        wildFuryAnimation.AnimationFactory.prototype.vbf = null;
        wildFuryAnimation.AnimationFactory.prototype.context = null;
        wildFuryAnimation.AnimationFactory.prototype.getComponentDeclaration = function() {
            return wildFuryAnimationDeclaration.AnimationDeclaration;
        };
        wildFuryAnimation.AnimationFactory.prototype.createComponent = function(context) {
            var cfgId = context.getConfiguration();
            new wildFuryAnimation.Animation(context, this.vbf, cfgId);
        };
        wildFuryAnimation.AnimationFactory.prototype.__class__ = wildFuryAnimation.AnimationFactory;
        wildFuryAnimation.ExternalService = function() {};
        wildFuryAnimation.ExternalService.__name__ = ["wildFuryAnimation", "ExternalService"];
        wildFuryAnimation.ExternalService.displayProvider = null;
        wildFuryAnimation.ExternalService.assetRegistry = null;
        wildFuryAnimation.ExternalService.variableRegistry = null;
        wildFuryAnimation.ExternalService.bus = null;
        wildFuryAnimation.ExternalService.busChanel = null;
        wildFuryAnimation.ExternalService.logger = null;
        wildFuryAnimation.ExternalService.viewBuilderFactory = null;
        wildFuryAnimation.ExternalService.uiHelper = null;
        wildFuryAnimation.ExternalService.initialize = function(context) {
            wildFuryAnimation.ExternalService.displayProvider = context.getAnyService(displayEngineApi.IDisplayProvider, null);
            wildFuryAnimation.ExternalService.assetRegistry = context.getAnyService(clientkernelLoaderApi.IAssetRegistry, null);
            wildFuryAnimation.ExternalService.variableRegistry = context.getAnyService(clientkernelLoaderApi.IVariableRegistry, null);
            wildFuryAnimation.ExternalService.bus = context.getAnyService(clientkernelEventbusApi.IEventBus, null);
            wildFuryAnimation.ExternalService.busChanel = wildFuryAnimation.ExternalService.bus.getChannel("GFBus");
            var loggerFactory = context.getAnyService(clientkernelLoggerApi.ILoggerFactory, null);
            wildFuryAnimation.ExternalService.logger = loggerFactory.getDefaultLogger();
            wildFuryAnimation.ExternalService.uiHelper = uiHelper.UiHelper.getUiHelper(wildFuryAnimation.ExternalService.displayProvider);
        };
        wildFuryAnimation.ExternalService.getBus = function() {
            return wildFuryAnimation.ExternalService.bus;
        };
        wildFuryAnimation.ExternalService.loadConfig = function(config_id, configCallback) {
            wildFuryAnimation.ExternalService.assetRegistry.getAsset(config_id).getContent().then(function(data) {
                configCallback(data);
            });
        };
        wildFuryAnimation.ExternalService.getAsset = function(id) {
            return wildFuryAnimation.ExternalService.assetRegistry.getAsset(id).getContent();
        };
        wildFuryAnimation.ExternalService.isDevice = function() {
            return wildFuryAnimation.ExternalService.variableRegistry.get("skin") == "mobile" || wildFuryAnimation.ExternalService.variableRegistry.get("assetPack") == "mobile" || wildFuryAnimation.ExternalService.variableRegistry.get("skin") == "tablet" || wildFuryAnimation.ExternalService.variableRegistry.get("assetPack") == "tablet";
        };
        wildFuryAnimation.ExternalService.prototype.__class__ = wildFuryAnimation.ExternalService;

        wildFuryAnimation.IAnimationComponent = function() {}
        wildFuryAnimation.IAnimationComponent.prototype = {

            action: function(animAction) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            show: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            configure: function(config) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };
        wildFuryAnimation.AnimationComponentViewLogic = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = false;
            this.container = container;
            this.scalefactor = scalefactor;
            this.isAnimated = isAnimated;
            this.show();
            this.logger = wildFuryAnimation.ExternalService.logger;
            this.uiHelper = wildFuryAnimation.ExternalService.uiHelper;
        };
        wildFuryAnimation.AnimationComponentViewLogic = ck_implements(wildFuryAnimation.AnimationComponentViewLogic, wildFuryAnimation.IAnimationComponent);
        wildFuryAnimation.AnimationComponentViewLogic.__interfaces__ = [wildFuryAnimation.IAnimationComponent];
        wildFuryAnimation.AnimationComponentViewLogic.__name__ = ["wildFuryAnimation", "AnimationComponentViewLogic"];
        wildFuryAnimation.AnimationComponentViewLogic.prototype.logger = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.container = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.isAnimated = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.scalefactor = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.stage = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.userData = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.uiHelper = null;
        wildFuryAnimation.AnimationComponentViewLogic.prototype.show = function() {
            this.container.show();
            if (!this.isAnimated) this.container.getDisplayObject().setCacheAsBitmap(true);
        };
        wildFuryAnimation.AnimationComponentViewLogic.prototype.hide = function() {
            if (!this.isAnimated) this.container.getDisplayObject().setCacheAsBitmap(false);
            this.container.hide();
        };
        wildFuryAnimation.AnimationComponentViewLogic.prototype.action = function(animAction) {
            var _g = animAction.action;
            switch (_g[1]) {
                case 0:
                    this.show();
                    break;
                case 1:
                    this.hide();
                    break;
                case 2:
                    this.handleAdditionalAction(animAction);
                    break;
            }
        };
        wildFuryAnimation.AnimationComponentViewLogic.prototype.handleAdditionalAction = function(animAction) {};
        wildFuryAnimation.AnimationComponentViewLogic.prototype.configure = function(config) {
            this.stage = this.container.getDisplayObject().getParent();
            this.userData = this.uiHelper.getUserDataFromVBContainer(this.container);
        };
        wildFuryAnimation.AnimationComponentViewLogic.prototype.__class__ = wildFuryAnimation.AnimationComponentViewLogic;
        wildFuryAnimation.BetPanelAdapatationComponent = function(container, scalefactor) {
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor);
            this.waitStageIsPresent($bind(this, this.waitBetPanelWillBePresent));
        };
        wildFuryAnimation.BetPanelAdapatationComponent.__name__ = ["wildFuryAnimation", "BetPanelAdapatationComponent"];
        wildFuryAnimation.BetPanelAdapatationComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.BetPanelAdapatationComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.plusButton = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.minusButton = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.checkButton = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.openTotalBetButton = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.totalBetPreview = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.totalBetLabelTitle = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.waitStageIsPresent = function(calback) {
            var _g = this;
            tools.Await.await(this.getParentIsStageBoolSupplier(), function() {
                calback(_hcmn_.js_Boot.__cast(_g.container.getDisplayObject().getParent(), displayEngineApi.IStage));
            });
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.waitBetPanelWillBePresent = function(stage) {
            var _g = this;
            this.stage = stage;
            if (wildFuryAnimation.ExternalService.isDevice()) tools.Await.await(this.getChildsIsPresentBoolSupplier(stage, wildFuryAnimation.BetPanelAdapatationComponent.DEVICE_CHILDS), function() {
                _g.initializeAfterLoadingDevice(stage);
                _g.updateBetPanel();
                _g.moveDevicesInfoPanelBgToBetPanel();
            });
            else tools.Await.await(this.getChildsIsPresentBoolSupplier(stage, wildFuryAnimation.BetPanelAdapatationComponent.DESKTOP_CHILDS), function() {
                _g.initializeAfterLoadingDesktop(stage);
                _g.moveDesktopInfoPanelBgToBetPanel();
            });
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.initializeAfterLoadingDevice = function(stage) {
            var bpOpen = stage.getChildByID("bp_open");
            var bpBet = stage.getChildByID("bp_bet");
            this.hideTotalBetDisplay(stage);
            var totalBetBtnContainer = bpOpen.getChildByName("OPEN_TOTAL_BET");
            var totalBetPopupContainer = bpBet.getChildByName("TOTAL_BET_CONTROL_MOBILE_IGT");
            var linesContainer = totalBetPopupContainer.getChildByName("LINES");
            linesContainer.getChildByName("VanityBarFill").setVisible(false);
            linesContainer.getChildByName("VanityBarBg").setVisible(false);
            var lineBet = totalBetPopupContainer.getChildByName("LINE_BET");
            this.plusButton = lineBet.getChildByName("PlusButton");
            this.minusButton = lineBet.getChildByName("MinusButton");
            this.totalBetPreview = totalBetPopupContainer.getChildByName("TOTAL_BET_PREVIEW");
            this.totalBetLabelTitle = totalBetBtnContainer.getChildByName("TotalBetLabelTitle");
            this.openTotalBetButton = totalBetBtnContainer.getChildByName("OpenTotalBetButton");
            totalBetBtnContainer.addChild(this.totalBetPreview);
            var totalBetLabel = totalBetBtnContainer.getChildByName("TotalBetLabel");
            this.totalBetPreview.setPos(totalBetLabel.getX(), totalBetLabel.getY());
            totalBetLabel.getParent().removeChild(totalBetLabel);
            window.onresize = $bind(this, this.updateLayout);
            this.checkButton = totalBetPopupContainer.getChildByName("CheckButton");
            this.addBetPanelButtonsHitArea();
            this.addBtnListeners(this.checkButton);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.initializeAfterLoadingDesktop = function(stage) {
            var bpBar = stage.getChildByID("bp_bar");
            var totalBetContainer = bpBar.getChildByName("TOTAL_BET_CONTROL_DESKTOP_IGT");
            var lineBet = totalBetContainer.getChildByName("LINE_BET");
            lineBet.removeChild(lineBet.getChildByName("StepperValueLabel"));
            lineBet.removeChild(lineBet.getChildByName("VanityBarFill"));
            lineBet.removeChild(lineBet.getChildByName("VanityBarBg"));
            totalBetContainer.removeChild(totalBetContainer.getChildByName("BetPerLineTitle"));
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.addBetPanelButtonsHitArea = function() {
            var halfBtnHeight = _hcmn_.Math.round(this.plusButton.getWidth() / 2);
            this.plusButton.setHitArea(this.getScaledHitAreaPolygon(halfBtnHeight));
            halfBtnHeight = _hcmn_.Math.round(this.minusButton.getWidth() / 2);
            this.minusButton.setHitArea(this.getScaledHitAreaPolygon(halfBtnHeight));
            halfBtnHeight = _hcmn_.Math.round(this.checkButton.getWidth() / 2);
            this.checkButton.setHitArea(this.getScaledHitAreaPolygon(halfBtnHeight));
            this.showBtnOfBetPanelMasks(halfBtnHeight);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getScaledHitAreaPolygon = function(radius) {
            return this.uiHelper.getHitAreaPolygon(radius * this.scalefactor, 15);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getScaledMaskPolygon = function(radius) {
            return this.uiHelper.getMaskPolygon(radius * this.scalefactor, 15);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.showBtnOfBetPanelMasks = function(halfBtnHeight) {};
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.addBtnListeners = function(checkBtn) {
            this.registerBtnClickHandler(checkBtn);
            this.registerBtnClickHandler(this.openTotalBetButton);
            window.document.body.ontouchend = $bind(this, this.onBtnOut);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.onBtnOut = function(e) {
            this.handleBtnFrameToEnable(this.openTotalBetButton);
            this.handleBtnFrameToEnable(this.plusButton);
            this.handleBtnFrameToEnable(this.minusButton);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.handleBtnFrameToEnable = function(btn) {
            var frame = this.getBtnFrame(btn);
            if (frame != "disabled" && frame != "enabled") btn.gotoAndStop("enabled");
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getBtnFrame = function(btn) {
            return eval("btn.currentStateName");
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.registerBtnClickHandler = function(btn) {
            var handler = this.getBtnClickHandler(btn);
            btn.on(displayEngineApi.DisplayObjectEvents.MOUSE_DOWN, handler);
            btn.on(displayEngineApi.DisplayObjectEvents.TOUCH_START, handler);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getBtnClickHandler = function(btn) {
            var _g = this;
            var btnName = btn.getName();
            var busChanel = wildFuryAnimation.ExternalService.busChanel;
            var onBtnClick = function(e) {
                var frame = _g.getBtnFrame(btn);
                if (frame != "disabled") {
                    busChanel.publish("betpanel:uiClicked", btnName);
                    busChanel.publish("betpanel:uiClicked:" + btnName, btnName);
                }
            };
            return onBtnClick;
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.moveDesktopInfoPanelBgToBetPanel = function() {
            var bpBar = this.stage.getChildByID("bp_bar");
            var infoBannerBkg = this.getInfoBannerBkg();
            var bkgPanel = bpBar.getChildByName("BkgPanel");
            var userData = this.uiHelper.getUserData(bkgPanel);
            infoBannerBkg.setY(-Math.abs(userData.viewBuilderH - infoBannerBkg.getHeight()) + bkgPanel.getY());
            infoBannerBkg.setX(bkgPanel.getX());
            infoBannerBkg.setWidth(bkgPanel.getWidth());
            bpBar.addChild(infoBannerBkg);
            infoBannerBkg.sendToBottom();
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.moveDevicesInfoPanelBgToBetPanel = function() {
            var bpBar = this.stage.getChildByID("bp_bar");
            var infoBannerBkg = this.getInfoBannerBkg();
            var userData = this.uiHelper.getUserData(bpBar);
            infoBannerBkg.setY(-Math.abs(userData.viewBuilderH - infoBannerBkg.getHeight()));
            bpBar.addChild(infoBannerBkg);
            infoBannerBkg.sendToBottom();
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getInfoBannerBkg = function() {
            var infoBar = this.stage.getChildByID("INFO_BAR");
            return (_hcmn_.js_Boot.__cast(infoBar.getChildByName("secundaryPanel"), displayEngineApi.IDisplayObjectContainer)).getChildByName("bkg");
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.updateBetPanel = function() {
            var reset1 = this.getResetLayoutForDoF(this.openTotalBetButton);
            var reset2 = this.getResetLayoutForDoF(this.totalBetPreview);
            var reset3 = this.getResetLayoutForDoF(this.totalBetLabelTitle);
            this.resetLayoutF = function() {
                reset1();
                reset2();
                reset3();
            };
            this.updateLayout();
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.hideTotalBetDisplay = function(stage) {
            var bpBar = stage.getChildByID("bp_bar");
            bpBar.getChildByName("TOTAL_BET_DISPLAY").setVisible(false);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getResetLayoutForDoF = function(displayObject) {
            var doX = displayObject.getX();
            var doY = displayObject.getY();
            var doZ = displayObject.getZOrder();
            return function() {
                displayObject.setX(doX);
                displayObject.setY(doY);
                displayObject.setZOrder(doZ);
            };
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.resetLayoutF = null;
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.updateLayout = function() {
            var _g = this;
            this.resetLayoutF();
            this.updateOpenTotalBetLayout();
            window.setTimeout(function() {
                _g.resetLayoutF();
                _g.updateOpenTotalBetLayout();
            }, 1);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.updateOpenTotalBetLayout = function() {
            if (this.openTotalBetButton.getRotation() == 90) {
                this.openTotalBetButton.setX(this.openTotalBetButton.getX() + this.openTotalBetButton.getWidth());
                this.totalBetPreview.setY((this.totalBetPreview.getY() + this.totalBetPreview.getHeight()) * .5);
                this.totalBetLabelTitle.setY(this.totalBetPreview.getY() + this.totalBetLabelTitle.getHeight() * 1.5);
            } else if (this.openTotalBetButton.getRotation() == -90) {
                this.openTotalBetButton.setY(this.openTotalBetButton.getY() + this.openTotalBetButton.getHeight());
                this.totalBetLabelTitle.setX((this.openTotalBetButton.getHeight() - this.totalBetLabelTitle.getWidth()) * .5);
                this.totalBetPreview.setX((this.openTotalBetButton.getHeight() - this.totalBetPreview.getWidth()) * .5);
            } else if (this.openTotalBetButton.getRotation() == 180) {
                this.openTotalBetButton.setY(this.openTotalBetButton.getY() + this.openTotalBetButton.getHeight());
                this.openTotalBetButton.setX(this.openTotalBetButton.getX() + this.openTotalBetButton.getWidth());
                this.totalBetLabelTitle.setX(this.openTotalBetButton.getWidth() * .9 - this.totalBetLabelTitle.getWidth());
                this.totalBetPreview.setX(this.openTotalBetButton.getWidth() * .9 - this.totalBetPreview.getWidth());
            }
            this.openTotalBetButton.setZOrder(0);
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getParentIsStageBoolSupplier = function() {
            var _g = this;
            return function() {
                return _hcmn_.Std["is"](_g.container.getDisplayObject().getParent(), displayEngineApi.IStage);
            };
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.getChildsIsPresentBoolSupplier = function(stage, childs) {
            var _g = this;
            return function() {
                return _g.isChildsPresent(stage, childs);
            };
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.isChildsPresent = function(stage, childs) {
            var _g = 0;
            while (_g < childs.length) {
                var childName = childs[_g];
                ++_g;
                if (stage.getChildByID(childName) == null) return false;
            }
            return true;
        };
        wildFuryAnimation.BetPanelAdapatationComponent.prototype.__class__ = wildFuryAnimation.BetPanelAdapatationComponent;
        wildFuryAnimation.DragonWayControl = function(dragonName, dragonsContainerList, dragonsWayProvider) {
            this.prevCall = 0.0;
            this.intervalId = 0;
            this.customScale = 1.0;
            this.overrideUseRotation = null;
            this.rotationPadding = 0;
            this.overrideLeftOrientation = null;
            this.isShown = false;
            this.dragonName = dragonName;
            this.dragons = [];
            this.dragonsWayProvider = dragonsWayProvider;
            this.dragonsProvider = dragonsContainerList;
        };
        wildFuryAnimation.DragonWayControl.__name__ = ["wildFuryAnimation", "DragonWayControl"];
        wildFuryAnimation.DragonWayControl.prototype.isShown = null;
        wildFuryAnimation.DragonWayControl.prototype.config = null;
        wildFuryAnimation.DragonWayControl.prototype.dragons = null;
        wildFuryAnimation.DragonWayControl.prototype.overrideLeftOrientation = null;
        wildFuryAnimation.DragonWayControl.prototype.rotationPadding = null;
        wildFuryAnimation.DragonWayControl.prototype.dragonsWayProvider = null;
        wildFuryAnimation.DragonWayControl.prototype.overrideUseRotation = null;
        wildFuryAnimation.DragonWayControl.prototype.width = null;
        wildFuryAnimation.DragonWayControl.prototype.height = null;
        wildFuryAnimation.DragonWayControl.prototype.actualWidth = null;
        wildFuryAnimation.DragonWayControl.prototype.actualHeight = null;
        wildFuryAnimation.DragonWayControl.prototype.widthWithPadding = null;
        wildFuryAnimation.DragonWayControl.prototype.heightWithPadding = null;
        wildFuryAnimation.DragonWayControl.prototype.customScale = null;
        wildFuryAnimation.DragonWayControl.prototype.spawnIntervalDelay = null;
        wildFuryAnimation.DragonWayControl.prototype.onAnimationCompleteCalbackFunction = null;
        wildFuryAnimation.DragonWayControl.prototype.dragonsProvider = null;
        wildFuryAnimation.DragonWayControl.prototype.dragonName = null;
        wildFuryAnimation.DragonWayControl.prototype.intervalId = null;
        wildFuryAnimation.DragonWayControl.prototype.prevCall = null;
        wildFuryAnimation.DragonWayControl.prototype.useLeftOrientation = function(value) {
            this.overrideLeftOrientation = value;
            return this;
        };
        wildFuryAnimation.DragonWayControl.prototype.useRotation = function(value) {
            if (value == null) value = true;
            this.overrideUseRotation = value;
            return this;
        };
        wildFuryAnimation.DragonWayControl.prototype.useRotationPadding = function(value) {
            this.useRotation(true);
            this.rotationPadding = value;
            return this;
        };
        wildFuryAnimation.DragonWayControl.prototype.showDragons = function() {
            var _g1 = 0;
            var _g = this.dragons.length;
            while (_g1 < _g) {
                var i = _g1++;
                var dragon = this.dragons[i];
                var timeout = this.spawnIntervalDelay * i | 0;
                window.setTimeout((function(f, i1, a1) {
                    return function() {
                        f(i1, a1);
                    };
                })($bind(this, this.playAnimation), i, dragon), timeout);
            }
            var actualFrame = 0;
            window.clearInterval(this.intervalId);
            this.intervalId = window.setInterval(this.getDragonDrawer(), this.spawnIntervalDelay);
            this.registerAnimationEndHandlerOfTheLastDragon(this.dragons[this.dragons.length - 1]);
        };
        wildFuryAnimation.DragonWayControl.prototype.getDragonDrawer = function() {
            var _g = this;
            var dragons = this.dragons.slice();
            var uiHelper = wildFuryAnimation.ExternalService.uiHelper;
            var wrappedDragons = _hcmn_.Lambda.array(_hcmn_.Lambda.map(dragons, $bind(uiHelper, uiHelper.wrapAsMovieClip)));
            wrappedDragons.reverse();
            this.prevCall = new _hcmn_.Date().getTime();
            return function() {
                _g.redrawAllDragons(wrappedDragons);
            };
        };
        wildFuryAnimation.DragonWayControl.prototype.redrawAllDragons = function(dragons) {
            var currentFrame = 0;
            var isHead = true;
            var _g = 0;
            while (_g < dragons.length) {
                var dragon = dragons[_g];
                ++_g;
                if (dragon.frameCount > 0) {
                    if (isHead) {
                        isHead = false;
                        var time = new _hcmn_.Date().getTime();
                        if (this.prevCall == 0) this.prevCall = time;
                        var step = _hcmn_.Math.round((time - this.prevCall) / 33);
                        if (step > 0) this.prevCall = time;
                        if (_hcmn_.HxOverrides.indexOf(dragons, dragon, 0) == 0) currentFrame = dragon.frameCount + step;
                        else if (dragon.frameCount == 1) currentFrame = 0;
                    }
                    currentFrame = _hcmn_.Math.round(_hcmn_.Math.min(currentFrame, dragon.getFramesAmount()));
                    dragon.gotoAndStopOnFrame(currentFrame);
                    currentFrame++;
                }
            }
        };
        wildFuryAnimation.DragonWayControl.prototype.registerAnimationEndHandlerOfTheLastDragon = function(dragon) {
            var _g = this;
            this.isShown = true;
            this.resetAnimation(dragon);
            dragon.addEventListener("ANIMATION::end", function() {
                window.clearInterval(_g.intervalId);
                _g.resetAnimation(dragon);
                _g.isShown = false;
                _g.dragons = [];
                if (_g.onAnimationCompleteCalbackFunction != null) {
                    _g.onAnimationCompleteCalbackFunction();
                    _g.onAnimationCompleteCalbackFunction = null;
                }
            });
        };
        wildFuryAnimation.DragonWayControl.prototype.playAnimation = function(i, animation) {
            animation.show();
            animation.frameCount = 1;
            (this.getDragonDrawer())();
        };
        wildFuryAnimation.DragonWayControl.prototype.resetAnimation = function(animation) {
            animation.gotoAndStop(false, "firstFrame");
            animation.getDisplayObject().setScaleX(this.customScale);
            animation.getDisplayObject().setScaleY(this.customScale);
            animation.getDisplayObject().setRotation(0);
            animation.hide();
            animation.addEventListener("ANIMATION::end", (function(f, a1) {
                return function() {
                    f(a1);
                };
            })($bind(this, this.resetAnimation), animation));
        };
        wildFuryAnimation.DragonWayControl.prototype.onAnimationComplete = function(calbackFunction) {
            this.onAnimationCompleteCalbackFunction = calbackFunction;
        };
        wildFuryAnimation.DragonWayControl.prototype.setupDragonsPosition = function(useRotation) {
            var _g = this;
            var xyCalculation = this.dragonsWayProvider.getDataProvider();
            var xyCalculationWithCorectionOnStage = function(actualStep) {
                var position = xyCalculation(actualStep);
                position.x = position.x * (_g.width + _g.actualWidth / 2) - _g.actualWidth / 4;
                position.y = position.y * (_g.height + _g.actualHeight / 2) - _g.actualHeight / 4;
                return position;
            };
            var step = 1 / this.dragons.length;
            var _g1 = 0;
            var _g2 = this.dragons.length;
            while (_g1 < _g2) {
                var i = _g1++;
                var dragonDO = this.dragons[i].getDisplayObject();
                var position1 = xyCalculationWithCorectionOnStage(step * i);
                var nextPosition = xyCalculationWithCorectionOnStage(step * (i + 1));
                this.setDragonPositionWithAdaptToWay(dragonDO, position1, nextPosition, useRotation);
            }
        };
        wildFuryAnimation.DragonWayControl.prototype.setDragonPositionWithAdaptToWay = function(dragon, position, nextPosition, useRotation) {
            if (this.overrideUseRotation == null) useRotation = useRotation;
            else useRotation = this.overrideUseRotation;
            var isLeftOrientation;
            if (this.overrideLeftOrientation == null) isLeftOrientation = nextPosition.x < position.x;
            else isLeftOrientation = this.overrideLeftOrientation;
            var rotation = 0.0;
            var scaleX = this.customScale;
            var scaleY = this.customScale;
            if (useRotation) rotation = uiHelper.GuiMath.angleOfVector(uiHelper.GuiMath.subtractPoint(nextPosition, position)) + this.rotationPadding;
            if (isLeftOrientation) scaleX = -scaleX;
            this.setDragonPosition(dragon, position, scaleX, scaleY, rotation);
        };
        wildFuryAnimation.DragonWayControl.prototype.setDragonPosition = function(dragon, position, scaleX, scaleY, rotation) {
            dragon.setX(position.x);
            dragon.setY(position.y);
            dragon.setScaleX(scaleX * position.z);
            dragon.setScaleY(scaleY * position.z);
            dragon.setRotation(rotation);
        };
        wildFuryAnimation.DragonWayControl.prototype.configure = function(userData, stage, vfxConfig, scalefactor) {
            this.config = vfxConfig;
            this.width = stage.getWidth();
            this.height = stage.getHeight();
            this.customScale = this.calculateCustomScale(userData);
            this.actualWidth = userData.viewBuilderW * this.customScale;
            this.actualHeight = userData.viewBuilderH * this.customScale;
            this.widthWithPadding = this.width + this.actualWidth * 2;
            this.heightWithPadding = this.height + this.actualHeight * 2;
            this.customScale *= 1 / scalefactor;
            if (!this.isShown) this.calculateIntervals(this.getExpectedAmountOfItems(stage));
        };
        wildFuryAnimation.DragonWayControl.prototype.getExpectedAmountOfItems = function(stage) {
            if (this.isShown) return this.dragons.length;
            var result = this.widthWithPadding / this.actualWidth;
            result *= this.config.numberOfImposition;
            return result | 0;
        };
        wildFuryAnimation.DragonWayControl.prototype.calculateCustomScale = function(userData) {
            var expectedScale = this.config.scale;
            var defaultStage = wildFuryAnimation.ExternalService.displayProvider.getDefaultStage();
            var scaleRelativeElement = defaultStage.getChildByID(this.config.scaleRelativeElement);
            if (scaleRelativeElement == null) return 1;
            var scaleRelativeElementUserData = uiHelper.UiHelper.getSimpleHelper().getUserData(scaleRelativeElement);
            var defaultStageScale = defaultStage.getScaleY();
            return expectedScale * scaleRelativeElementUserData.viewBuilderH / userData.viewBuilderH * defaultStageScale;
        };
        wildFuryAnimation.DragonWayControl.prototype.calculateIntervals = function(expectedAmountOfItems) {
            this.spawnIntervalDelay = this.config.timeDuration / expectedAmountOfItems | 0;
            this.collectShownDragons(expectedAmountOfItems, this.spawnIntervalDelay);
        };
        wildFuryAnimation.DragonWayControl.prototype.collectShownDragons = function(expectedAmountOfItems, spawnIntervalDelay) {
            var expectedFps = _hcmn_.Std["int"](_hcmn_.Math.max(_hcmn_.Math.min(1000 / (spawnIntervalDelay * 3), 60), this.config.defaultFps));
            var uiHelper = wildFuryAnimation.ExternalService.uiHelper;
            this.dragons = this.dragonsProvider.getDragonsList(expectedAmountOfItems, this.dragonName);
            var _g = 0;
            var _g1 = this.dragons;
            while (_g < _g1.length) {
                var dragon = _g1[_g];
                ++_g;
                this.resetAnimation(dragon);
                uiHelper.setFps(dragon, expectedFps);
            }
        };
        wildFuryAnimation.DragonWayControl.prototype.__class__ = wildFuryAnimation.DragonWayControl;

        wildFuryAnimation.IViewBuilderSetter = function() {}
        wildFuryAnimation.IViewBuilderSetter.prototype = {

            setViewBuilder: function(value) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };
        wildFuryAnimation.DragonsComponent = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = false;
            this.useRotation = false;
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, isAnimated);
            this.dragonsWays = new wildFuryAnimation.DragonsWays();
        };
        wildFuryAnimation.DragonsComponent = ck_implements(wildFuryAnimation.DragonsComponent, wildFuryAnimation.IViewBuilderSetter);
        wildFuryAnimation.DragonsComponent.__interfaces__ = [wildFuryAnimation.IViewBuilderSetter];
        wildFuryAnimation.DragonsComponent.__name__ = ["wildFuryAnimation", "DragonsComponent"];
        wildFuryAnimation.DragonsComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.DragonsComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.DragonsComponent.prototype.useRotation = null;
        wildFuryAnimation.DragonsComponent.prototype.goldDragonWayControl = null;
        wildFuryAnimation.DragonsComponent.prototype.blueDragonWayControl = null;
        wildFuryAnimation.DragonsComponent.prototype.goldDragonHorizontalWayControl = null;
        wildFuryAnimation.DragonsComponent.prototype.blueDragonHorizontalWayControl = null;
        wildFuryAnimation.DragonsComponent.prototype.dragonsWays = null;
        wildFuryAnimation.DragonsComponent.prototype.config = null;
        wildFuryAnimation.DragonsComponent.prototype.action = function(animAction) {
            if (_hcmn_.js_Boot.__instanceof(animAction.data, wildFuryAnimationPort.DragonAction)) this.handleAction(animAction.action, animAction.data);
            else wildFuryAnimation.AnimationComponentViewLogic.prototype.action.call(this, animAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.handleAction = function(action, dragonAction) {
            if (action == wildFuryAnimationPort.Action.SHOW) {
                this.show();
                this.dragonsWays.updateActualWayIndex();
                this.useRotation = _hcmn_.Std.random(2) == 1;
                this.showDragonAnimation(dragonAction);
            } else this.hide();
        };
        wildFuryAnimation.DragonsComponent.prototype.showDragonAnimation = function(dragonAction) {
            var _g = dragonAction.dragonType;
            switch (_g[1]) {
                case 3:
                    this.showTauntBlueDragon(dragonAction);
                    break;
                case 2:
                    this.showTauntGoldDragon(dragonAction);
                    break;
                case 5:
                    this.showTauntBlueDragonPart2(dragonAction);
                    return;
                case 4:
                    this.showTauntGoldDragonPart2(dragonAction);
                    return;
                case 1:
                    this.showRegularDragon(this.blueDragonHorizontalWayControl, dragonAction, this.config.horizontalBlueDragon, 0);
                    break;
                case 0:
                    this.showRegularDragon(this.goldDragonHorizontalWayControl, dragonAction, this.config.horizontalGoldDragon, 180);
                    break;
                case 6:
                    this.showVerticalDragons(dragonAction);
                    break;
            }
            wildFuryAnimation.ExternalService.busChanel.publish("dragons:spawn", dragonAction.dragonType[0]);
        };
        wildFuryAnimation.DragonsComponent.prototype.showVerticalDragons = function(dragonAction) {
            this.setupGoldDragons();
            this.setupBlueDragons();
            this.showGoldDragons();
            this.showBlueDragons();
            this.registerAnimationEndHandler([this.goldDragonWayControl, this.blueDragonWayControl], dragonAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntBlueDragon = function(dragonAction) {
            var _g = this;
            var dragonWayControl = this.blueDragonHorizontalWayControl;
            var dragonActionWrapper = new wildFuryAnimationPort.DragonAction(dragonAction.dragonType, function(data) {
                dragonAction.animationEndHandler(dragonAction.dragonType);
                _g.showDragonAnimation(new wildFuryAnimationPort.DragonAction(wildFuryAnimationPort.DragonType.TAUNT_BLUE_PART_2, dragonAction.animationEndHandler));
            });
            this.showTauntDragonsPart1(dragonWayControl, this.config.horizontalBlueDragon, 0, dragonActionWrapper);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntGoldDragon = function(dragonAction) {
            var _g = this;
            var dragonWayControl = this.goldDragonHorizontalWayControl;
            var dragonActionWrapper = new wildFuryAnimationPort.DragonAction(dragonAction.dragonType, function(data) {
                dragonAction.animationEndHandler(dragonAction.dragonType);
                _g.showDragonAnimation(new wildFuryAnimationPort.DragonAction(wildFuryAnimationPort.DragonType.TAUNT_GOLD_PART_2, dragonAction.animationEndHandler));
            });
            this.showTauntDragonsPart1(dragonWayControl, this.config.horizontalGoldDragon, 180, dragonActionWrapper);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntBlueDragonPart2 = function(dragonAction) {
            this.showTauntDragonsPart2(this.blueDragonHorizontalWayControl, this.config.tauntHorizontalBlueDragon, 180, dragonAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntGoldDragonPart2 = function(dragonAction) {
            this.showTauntDragonsPart2(this.goldDragonHorizontalWayControl, this.config.tauntHorizontalGoldDragon, 0, dragonAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntDragonsPart1 = function(dragonWayControl, dragonVfxConfig, rotationPadding, dragonAction) {
            this.dragonsWays.setActualWayIndex(0);
            dragonWayControl.useRotationPadding(rotationPadding).useLeftOrientation(true);
            this.setupAndConfigureDragonsControl(dragonWayControl, dragonVfxConfig);
            dragonWayControl.showDragons();
            this.registerAnimationEndHandler([dragonWayControl], dragonAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.showTauntDragonsPart2 = function(dragonWayControl, dragonVfxConfig, rotationPadding, dragonAction) {
            var _g = this;
            window.setTimeout(function() {
                _g.dragonsWays.setActualWayIndex(1);
                dragonWayControl.useLeftOrientation(false).useRotationPadding(rotationPadding);
                _g.setupAndConfigureDragonsControl(dragonWayControl, dragonVfxConfig);
                dragonWayControl.showDragons();
                _g.registerAnimationEndHandler([dragonWayControl], dragonAction);
            }, 100);
        };
        wildFuryAnimation.DragonsComponent.prototype.showRegularDragon = function(dragonWayControl, dragonAction, dragonVfxConfig, rotationPadding) {
            dragonWayControl.useLeftOrientation(true).useRotationPadding(rotationPadding);
            this.setupAndConfigureDragonsControl(dragonWayControl, dragonVfxConfig);
            dragonWayControl.showDragons();
            this.registerAnimationEndHandler([dragonWayControl], dragonAction);
        };
        wildFuryAnimation.DragonsComponent.prototype.registerAnimationEndHandler = function(controls, dragonAction) {
            if (controls.length == 0) dragonAction.animationEndHandler(dragonAction.dragonType);
            else {
                var waiter = new tools.PromizesWaiter();
                this.collectPromizers(waiter, controls);
                waiter.await((function(f, a1) {
                    return function() {
                        f(a1);
                    };
                })(dragonAction.animationEndHandler, dragonAction.dragonType));
            }
        };
        wildFuryAnimation.DragonsComponent.prototype.collectPromizers = function(waiter, controls) {
            var _g = 0;
            while (_g < controls.length) {
                var control = [controls[_g]];
                ++_g;
                var promize = new Promise((function(control) {
                    return function(resolve, reject) {
                        control[0].onAnimationComplete(((function() {
                            return function(f, a1) {
                                return (function() {
                                    return function() {
                                        f(a1);
                                    };
                                })();
                            };
                        })())(resolve, null));
                    };
                })(control));
                waiter.awaitPromise(promize);
            }
        };
        wildFuryAnimation.DragonsComponent.prototype.showGoldDragons = function() {
            this.goldDragonWayControl.showDragons();
        };
        wildFuryAnimation.DragonsComponent.prototype.showBlueDragons = function() {
            this.blueDragonWayControl.showDragons();
        };
        wildFuryAnimation.DragonsComponent.prototype.setViewBuilder = function(value) {
            var _g = this;
            wildFuryAnimation.ExternalService.loadConfig("dragons-assets/config", function(data) {
                _g.config = data;
                var dragonsProvider = new wildFuryAnimation.DragonsProvider(_g.container, value);
                dragonsProvider.setupInitialDragonsList(_g.config.goldDragon.initialDragonLengths, "goldDragon");
                dragonsProvider.setupInitialDragonsList(_g.config.blueDragon.initialDragonLengths, "blueDragon");
                dragonsProvider.setupInitialDragonsList(_g.config.horizontalGoldDragon.initialDragonLengths, "goldenDragon_horizontal");
                dragonsProvider.setupInitialDragonsList(_g.config.horizontalBlueDragon.initialDragonLengths, "blueDragon_horizontal");
                _g.goldDragonWayControl = new wildFuryAnimation.DragonWayControl("goldDragon", dragonsProvider, _g.dragonsWays.getGoldWayGeneratorProvider()).useRotation(false).useRotationPadding(90).useLeftOrientation(false);
                _g.blueDragonWayControl = new wildFuryAnimation.DragonWayControl("blueDragon", dragonsProvider, _g.dragonsWays.getBlueWayGeneratorProvider()).useRotation(false).useRotationPadding(90).useLeftOrientation(false);
                _g.goldDragonHorizontalWayControl = new wildFuryAnimation.DragonWayControl("goldenDragon_horizontal", dragonsProvider, _g.dragonsWays.getGoldHorizontalWayGeneratorProvider()).useRotation().useLeftOrientation(true);
                _g.blueDragonHorizontalWayControl = new wildFuryAnimation.DragonWayControl("blueDragon_horizontal", dragonsProvider, _g.dragonsWays.getBlueHorizontalWayGeneratorProvider()).useRotationPadding(180).useLeftOrientation(true);
                _g.configureAllDragonWayControl();
            });
        };
        wildFuryAnimation.DragonsComponent.prototype.setupBlueDragons = function() {
            this.setupAndConfigureDragonsControl(this.blueDragonWayControl, this.config.blueDragon);
        };
        wildFuryAnimation.DragonsComponent.prototype.setupGoldDragons = function() {
            this.setupAndConfigureDragonsControl(this.goldDragonWayControl, this.config.goldDragon);
        };
        wildFuryAnimation.DragonsComponent.prototype.configure = function(config) {
            wildFuryAnimation.AnimationComponentViewLogic.prototype.configure.call(this, config);
            if (this.config != null) this.configureAllDragonWayControl();
        };
        wildFuryAnimation.DragonsComponent.prototype.configureAllDragonWayControl = function() {
            this.setupAndConfigureDragonsControl(this.goldDragonWayControl, this.config.goldDragon, this.goldDragonWayControl.isShown);
            this.setupAndConfigureDragonsControl(this.blueDragonWayControl, this.config.blueDragon, this.blueDragonWayControl.isShown);
            this.setupAndConfigureDragonsControl(this.goldDragonHorizontalWayControl, this.config.horizontalGoldDragon, this.goldDragonHorizontalWayControl.isShown);
            this.setupAndConfigureDragonsControl(this.blueDragonHorizontalWayControl, this.config.horizontalBlueDragon, this.blueDragonHorizontalWayControl.isShown);
        };
        wildFuryAnimation.DragonsComponent.prototype.setupAndConfigureDragonsControl = function(dragonWayControl, config, isShown) {
            if (isShown == null) isShown = true;
            if (isShown) {
                dragonWayControl.configure(this.userData, this.stage, config, this.scalefactor);
                dragonWayControl.setupDragonsPosition(this.useRotation);
            }
        };
        wildFuryAnimation.DragonsComponent.prototype.__class__ = wildFuryAnimation.DragonsComponent;
        wildFuryAnimation.DragonsProvider = function(container, viewBuilderContainer) {
            this.mapOfDragonsContainerList = new _hcmn_.haxe_ds_StringMap();
            this.container = container;
            this.viewBuilderContainer = viewBuilderContainer;
        };
        wildFuryAnimation.DragonsProvider.__name__ = ["wildFuryAnimation", "DragonsProvider"];
        wildFuryAnimation.DragonsProvider.prototype.mapOfDragonsContainerList = null;
        wildFuryAnimation.DragonsProvider.prototype.container = null;
        wildFuryAnimation.DragonsProvider.prototype.viewBuilderContainer = null;
        wildFuryAnimation.DragonsProvider.prototype.setupInitialDragonsList = function(expectedAmountOfItems, name) {
            this.getDragonsList(expectedAmountOfItems, name);
        };
        wildFuryAnimation.DragonsProvider.prototype.getDragonsList = function(expectedAmountOfItems, name) {
            var result = [];
            var _g = 0;
            var _g1 = this.getVbDragonsList(expectedAmountOfItems, name);
            while (_g < _g1.length) {
                var vbDragon = _g1[_g];
                ++_g;
                result.push(vbDragon.getVBAnimationById("content"));
            }
            return result;
        };
        wildFuryAnimation.DragonsProvider.prototype.getVbDragonsList = function(expectedAmountOfItems, name) {
            var dragonsContainerList = this.getDragonsContainerList(name);
            var amountOfUnavailableDragons = expectedAmountOfItems - dragonsContainerList.length;
            if (amountOfUnavailableDragons > 0) this.createNewDragons(amountOfUnavailableDragons, name);
            return dragonsContainerList.slice(0, expectedAmountOfItems);
        };
        wildFuryAnimation.DragonsProvider.prototype.createNewDragons = function(numberOfDragons, name) {
            var dragonsContainerList = this.getDragonsContainerList(name);
            var actualAmountOfDragons = dragonsContainerList.length;
            var _g = 0;
            while (_g < numberOfDragons) {
                var i = _g++;
                var dragonsContainer = this.container.createContainerFromStoredConfig(name);
                this.container.addChildComponent(dragonsContainer, "DRAGON_" + name + (i + actualAmountOfDragons));
                dragonsContainerList.push(dragonsContainer);
            }
        };
        wildFuryAnimation.DragonsProvider.prototype.getDragonsContainerList = function(name) {
            if (!this.mapOfDragonsContainerList.exists(name)) this.mapOfDragonsContainerList.set(name, []);
            return this.mapOfDragonsContainerList.get(name);
        };
        wildFuryAnimation.DragonsProvider.prototype.__class__ = wildFuryAnimation.DragonsProvider;

        wildFuryAnimation.IAnimationPortSetter = function() {}
        wildFuryAnimation.IAnimationPortSetter.prototype = {

            setAnimationPort: function(port) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };
        wildFuryAnimation.FlyingSymbolsComponent = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = true;
            this.symbolsList = new _hcmn_.haxe_ds_StringMap();
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, true);
        };
        wildFuryAnimation.FlyingSymbolsComponent = ck_implements(wildFuryAnimation.FlyingSymbolsComponent, wildFuryAnimation.IAnimationPortSetter);
        wildFuryAnimation.FlyingSymbolsComponent = ck_implements(wildFuryAnimation.FlyingSymbolsComponent, wildFuryAnimation.IViewBuilderSetter);
        wildFuryAnimation.FlyingSymbolsComponent.__interfaces__ = [wildFuryAnimation.IAnimationPortSetter, wildFuryAnimation.IViewBuilderSetter];
        wildFuryAnimation.FlyingSymbolsComponent.__name__ = ["wildFuryAnimation", "FlyingSymbolsComponent"];
        wildFuryAnimation.FlyingSymbolsComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.FlyingSymbolsComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.FlyingSymbolsComponent.prototype.port = null;
        wildFuryAnimation.FlyingSymbolsComponent.prototype.symbols = null;
        wildFuryAnimation.FlyingSymbolsComponent.prototype.config = null;
        wildFuryAnimation.FlyingSymbolsComponent.prototype.symbolsList = null;
        wildFuryAnimation.FlyingSymbolsComponent.prototype.endPointsMap = null;
        wildFuryAnimation.FlyingSymbolsComponent.prototype.handleAction = function(action, symbols) {
            if (action == wildFuryAnimationPort.Action.SHOW) {
                this.show();
                this.symbols = symbols.slice();
                window.setTimeout($bind(this, this.flyNextSymbol), this.config.delayBeforeStart);
            } else this.hide();
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.createAnimation = function(symbol) {
            var type = symbol.type;
            var entryValue = this.symbolsList.get(type);
            var animContainer = this.container.createContainerFromStoredConfig("ANIMATION_PLACE");
            this.container.addChildComponent(animContainer, "ANIMATION_PLACE");
            var animHolder = this.container.createContainerFromStoredConfig(type + "_ANIMATION_HOLDER");
            var anim = animHolder.getVBAnimationById("ANIMATION_HOLDER");
            animContainer.addChildComponent(anim, type + "_ANIMATION_HOLDER");
            var colAndRow = symbol.winningSymbol.split(",");
            this.setPosition(anim.getDisplayObject(), colAndRow[0], colAndRow[1], entryValue);
            anim.play(false);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.playAnimation = function(symbol) {
            this.createAnimation(symbol);
            var type = symbol.type;
            var animContainer = this.container.getContainerById("ANIMATION_PLACE");
            var animation = animContainer.getComponentById(type + "_ANIMATION_HOLDER");
            var endPoint = this.endPointsMap.get(type);
            displayEngineUtils.TweenX.to(animation.getDisplayObject(), {
                y: endPoint.y
            }, this.config.animationBasicTime, null, null, null, null, null, null, null, {
                fileName: "FlyingSymbolsComponent.hx",
                lineNumber: 56,
                className: "components.animation.components.FlyingSymbolsComponent",
                methodName: "playAnimation"
            });
            displayEngineUtils.TweenX.to(animation.getDisplayObject(), {
                x: endPoint.x,
                scaleX: 0.1,
                scaleY: 0.1
            }, this.config.animationBasicTime, null, null, null, null, null, null, null, {
                fileName: "FlyingSymbolsComponent.hx",
                lineNumber: 57,
                className: "components.animation.components.FlyingSymbolsComponent",
                methodName: "playAnimation"
            }).ease($bind(this, this.easyInFunction)).onFinish((function(f, a1) {
                return function() {
                    f(a1);
                };
            })($bind(this, this.handleAnimationComplete), type));
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.easyInFunction = function(d) {
            return _hcmn_.Math.pow(d, 4);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.handleAnimationComplete = function(type) {
            this.container.disposeChildComponent("ANIMATION_PLACE");
            this.port.getSymbolFlightComplete().publish(type);
            if (this.symbols.length > 0) this.flyNextSymbol();
            else this.port.getAllSymbolsFlightComplete().publish(type);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.flyNextSymbol = function() {
            var symbol = this.symbols.shift();
            window.setTimeout((function(f, a1) {
                return function() {
                    f(a1);
                };
            })($bind(this, this.playAnimation), symbol), this.config.delayBeforeNext);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.setPosition = function(symbolContainer, col, row, entryValue) {
            var position = this.getSymbolPosition(col, row);
            var x = position.x;
            var y = position.y;
            if (entryValue != null) {
                x += entryValue.paddingX;
                y += entryValue.paddingY;
            }
            symbolContainer.setPos(x, y);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.getSymbolPosition = function(col, row) {
            var symbolCol = _hcmn_.Std.parseInt(col);
            var symbolRow = _hcmn_.Std.parseInt(row);
            return new displayEngineApi.Point(this.config.cellWidth * symbolCol, this.config.cellHeight * symbolRow);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.action = function(animAction) {
            this.handleAction(animAction.action, animAction.data);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.show = function() {
            this.container.show();
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.registerSymbols = function() {
            var _g = 0;
            var _g1 = this.config.symbols;
            while (_g < _g1.length) {
                var entry = _g1[_g];
                ++_g;
                this.symbolsList.set(entry.key, entry.value);
            }
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.configure = function(config) {
            this.endPointsMap = new _hcmn_.haxe_ds_StringMap();
            var value = new displayEngineApi.Point(config.wildEndPointX, config.wildEndPointY);
            this.endPointsMap.set("WILD", value);
            var value1 = new displayEngineApi.Point(config.freespinEndPointX, config.freespinEndPointY);
            this.endPointsMap.set("FREESPIN", value1);
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.setViewBuilder = function(value) {
            var _g = this;
            wildFuryAnimation.ExternalService.loadConfig("flying-symbols-assets/flying_symbols_config", function(data) {
                _g.config = data;
                _g.registerSymbols();
            });
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.setAnimationPort = function(port) {
            this.port = port;
        };
        wildFuryAnimation.FlyingSymbolsComponent.prototype.__class__ = wildFuryAnimation.FlyingSymbolsComponent;
        wildFuryAnimation.LogoComponent = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = true;
            this.playTimeoutId = 0;
            var _g = this;
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, true);
            this.logoheader = container.getVBAnimationById("LOGOHEADER");
            this.logoheader.addEventListener(wildFuryAnimation.LogoComponent.ANIMATION_END_EVENT, function() {
                _g.pauseAnimation();
                var timeout = (_hcmn_.Std.random(10) + 5) * 1000;
                _g.playTimeoutId = window.setTimeout($bind(_g, _g.playAnimation), timeout);
            });
            this.playAnimation();
        };
        wildFuryAnimation.LogoComponent.__name__ = ["wildFuryAnimation", "LogoComponent"];
        wildFuryAnimation.LogoComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.LogoComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.LogoComponent.prototype.logoheader = null;
        wildFuryAnimation.LogoComponent.prototype.playTimeoutId = null;
        wildFuryAnimation.LogoComponent.prototype.playAnimation = function() {
            this.logoheader.play(false);
        };
        wildFuryAnimation.LogoComponent.prototype.pauseAnimation = function() {
            this.logoheader.gotoAndStop(false, "firstFrame");
            window.clearTimeout(this.playTimeoutId);
        };
        wildFuryAnimation.LogoComponent.prototype.__class__ = wildFuryAnimation.LogoComponent;
        wildFuryAnimation.ParticleComponent = function(container, scalefactor) {
            this.activeParticles = new _hcmn_.haxe_ds_StringMap();
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, true);
            this.hide();
            this.displaObjectContainer = container.getDisplayObject();
            this.displaObjectContainer.getChildByName("rect").setVisible(false);
            this.displaObjectContainer.setCacheAsBitmap(false);
        };
        wildFuryAnimation.ParticleComponent.__name__ = ["wildFuryAnimation", "ParticleComponent"];
        wildFuryAnimation.ParticleComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.ParticleComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.ParticleComponent.prototype.displaObjectContainer = null;
        wildFuryAnimation.ParticleComponent.prototype.activeParticles = null;
        wildFuryAnimation.ParticleComponent.prototype.show = function() {
            this.container.show();
            this.container.getDisplayObject().setCacheAsBitmap(false);
        };
        wildFuryAnimation.ParticleComponent.prototype.action = function(animAction) {
            wildFuryAnimation.AnimationComponentViewLogic.prototype.action.call(this, animAction);
            var data;
            if (_hcmn_.js_Boot.__instanceof(animAction.data, wildFuryAnimationPort.ParticlePayload)) data = animAction.data;
            else {
                this.logger.warn("unavailable data to execute action for particle component");
                return;
            }
            var _g = animAction.action;
            switch (_g[1]) {
                case 0:
                    this.playParticle(data);
                    break;
                case 1:
                    this.stopParticle(data.name);
                    break;
                default:
            }
        };
        wildFuryAnimation.ParticleComponent.prototype.playParticle = function(particle) {
            this.setParticleMask(particle.isMasked);
            if (particle.zIndex >= 0) this.displaObjectContainer.setZIndex(particle.zIndex);
            if (this.activeParticles.exists(particle.name)) this.stopParticle(particle.name);
            var animConfig = new wildFuryAnimation.AnimationConfig();
            animConfig.colorStart = particle.colorStart;
            animConfig.colorEnd = particle.colorEnd;
            var value = new wildFuryAnimation.ParticlePlayerFromConfig(particle.name);
            this.activeParticles.set(particle.uname, value);
            this.activeParticles.get(particle.uname).playParticle(this.displaObjectContainer, new displayEngineApi.Point(particle.position.x, particle.position.y), animConfig);
        };
        wildFuryAnimation.ParticleComponent.prototype.stopParticle = function(particle) {
            if (this.activeParticles.exists(particle)) {
                this.activeParticles.get(particle).stop();
                this.activeParticles.remove(particle);
            }
        };
        wildFuryAnimation.ParticleComponent.prototype.setParticleMask = function(isMasked) {
            if (isMasked) this.uiHelper.addMask(this.displaObjectContainer, wildFuryAnimation.MaskPoints.WIN_METTER_MASK_POINTS, 125, 0);
            else this.uiHelper.clearMask(this.displaObjectContainer);
        };
        wildFuryAnimation.ParticleComponent.prototype.__class__ = wildFuryAnimation.ParticleComponent;
        wildFuryAnimation.PromoComponent = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = true;
            this.animationCompleteCounter = 0;
            this.isPause = false;
            this.isActive = true;
            this.isInitialized = false;
            this.isHiddingNeeds = false;
            this.isVisible = false;
            this.promoIndex = 0;
            this.vba = null;
            this.playTimeoutId = 0;
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, true);
            this.currentState = "PROMO_HIDDEN";
            this.isEnglishLocale = wildFuryAnimation.ExternalService.variableRegistry.get("language").indexOf("en") >= 0;
        };
        wildFuryAnimation.PromoComponent = ck_implements(wildFuryAnimation.PromoComponent, wildFuryAnimation.IViewBuilderSetter);
        wildFuryAnimation.PromoComponent.__interfaces__ = [wildFuryAnimation.IViewBuilderSetter];
        wildFuryAnimation.PromoComponent.__name__ = ["wildFuryAnimation", "PromoComponent"];
        wildFuryAnimation.PromoComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.PromoComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.PromoComponent.prototype.promo = null;
        wildFuryAnimation.PromoComponent.prototype.playTimeoutId = null;
        wildFuryAnimation.PromoComponent.prototype.vba = null;
        wildFuryAnimation.PromoComponent.prototype.promoIndex = null;
        wildFuryAnimation.PromoComponent.prototype.isVisible = null;
        wildFuryAnimation.PromoComponent.prototype.promoTimeout = null;
        wildFuryAnimation.PromoComponent.prototype.promoSectionDuration = null;
        wildFuryAnimation.PromoComponent.prototype.leftAnimation = null;
        wildFuryAnimation.PromoComponent.prototype.rightAnimation = null;
        wildFuryAnimation.PromoComponent.prototype.leftAnimationContainer = null;
        wildFuryAnimation.PromoComponent.prototype.rightAnimationContainer = null;
        wildFuryAnimation.PromoComponent.prototype.leftContainerPosition = null;
        wildFuryAnimation.PromoComponent.prototype.rigthContainerPosition = null;
        wildFuryAnimation.PromoComponent.prototype.currentState = null;
        wildFuryAnimation.PromoComponent.prototype.isHiddingNeeds = null;
        wildFuryAnimation.PromoComponent.prototype.isInitialized = null;
        wildFuryAnimation.PromoComponent.prototype.isEnglishLocale = null;
        wildFuryAnimation.PromoComponent.prototype.isActive = null;
        wildFuryAnimation.PromoComponent.prototype.isPause = null;
        wildFuryAnimation.PromoComponent.prototype.animationCompleteCounter = null;
        wildFuryAnimation.PromoComponent.prototype.action = function(animAction) {
            if (wildFuryAnimation.ExternalService.isDevice()) this.handleAction(animAction);
        };
        wildFuryAnimation.PromoComponent.prototype.hide = function() {
            this.isHiddingNeeds = this.currentState != "PROMO_HIDDEN";
            if (this.currentState == "PROMO_SHOWS") {
                window.clearTimeout(this.promoTimeout);
                this.playPromoSectionHidding();
            }
        };
        wildFuryAnimation.PromoComponent.prototype.handleAdditionalAction = function(animAction) {
            var _g = animAction.data;
            switch (_hcmn_.Type.enumIndex(_g)) {
                case 0:
                    this.isActive = true;
                    break;
                case 1:
                    this.isActive = false;
                    break;
                case 2:
                    this.isPause = true;
                    if (this.currentState == "PROMO_HIDDEN" && this.isActive) this.showAndPlay();
                    break;
                case 3:
                    this.isPause = false;
                    this.playPromoSectionHidding();
                    break;
            }
        };
        wildFuryAnimation.PromoComponent.prototype.hidePromoAnimation = function(animation) {
            this.animationCompleteCounter++;
            this.stopAnimation(animation, "PROMO:HIDDEN");
            if (this.animationCompleteCounter >= 2) this.hidePromoSection();
        };
        wildFuryAnimation.PromoComponent.prototype.hidePromoSection = function() {
            this.currentState = "PROMO_HIDDEN";
            wildFuryAnimation.AnimationComponentViewLogic.prototype.hide.call(this);
            this.isHiddingNeeds = false;
            this.resetAnimations();
            this.hideAllPromo();
            window.clearTimeout(this.promoTimeout);
        };
        wildFuryAnimation.PromoComponent.prototype.setViewBuilder = function(value) {
            var _g = this;
            var assetsToLoad = ["promo-assets/promo_animations", "promo-assets/promo_settings"];
            wildFuryAnimation.ExternalService.assetRegistry.getAssetsContent(assetsToLoad).then(function(data) {
                wildFuryAnimation.ExternalService.loadedAssets = data;
                _g.vba = wildFuryAnimation.ExternalService.loadedAssets.get("promo_animations");
                var config = wildFuryAnimation.ExternalService.loadedAssets.get("promo_settings");
                _g.promoSectionDuration = config.promo_section_duration;
            });
        };
        wildFuryAnimation.PromoComponent.prototype.createPromoAnimation = function() {
            this.initSideAnimationContainers();
        };
        wildFuryAnimation.PromoComponent.prototype.clearAnimation = function(animation) {
            if (animation != null) {
                animation.removeEventListener("PROMO:HIDDEN");
                animation.removeEventListener("PROMO:SHOWN");
                animation.gotoAndStop(false, "show");
                animation.getDisplayObject().setVisible(false);
            }
        };
        wildFuryAnimation.PromoComponent.prototype.resetAnimations = function() {
            this.clearAnimation(this.leftAnimation);
            this.clearAnimation(this.rightAnimation);
            window.clearTimeout(this.promoTimeout);
        };
        wildFuryAnimation.PromoComponent.prototype.playPromoSectionShowing = function(animation) {
            this.animationCompleteCounter++;
            this.stopAnimation(animation, "PROMO:HIDDEN");
            if (this.animationCompleteCounter >= 2) window.setTimeout($bind(this, this.playPromoSection), 1);
        };
        wildFuryAnimation.PromoComponent.prototype.playPromoSection = function() {
            var index = this.promoIndex % 5 + 1;
            this.resetAnimations();
            this.leftAnimation = this.leftAnimationContainer.getVBAnimationById("PROMO_" + index + "L_ANIMATION_CONTENT");
            this.rightAnimation = this.rightAnimationContainer.getVBAnimationById("PROMO_" + index + "R_ANIMATION_CONTENT");
            this.animationCompleteCounter = 0;
            this.rightAnimation.addEventListener("PROMO:SHOWN", (function(f, a1) {
                return function() {
                    f(a1);
                };
            })($bind(this, this.onPromoSectionShown), this.rightAnimation));
            this.leftAnimation.addEventListener("PROMO:SHOWN", (function(f1, a11) {
                return function() {
                    f1(a11);
                };
            })($bind(this, this.onPromoSectionShown), this.leftAnimation));
            this.leftAnimation.gotoAndPlay(false, "show");
            this.rightAnimation.gotoAndPlay(false, "show");
            this.currentState = "PROMO_SHOWING";
            this.promoIndex++;
        };
        wildFuryAnimation.PromoComponent.prototype.stopAnimation = function(animation, eventName) {
            animation.stop();
            animation.removeEventListener(eventName);
        };
        wildFuryAnimation.PromoComponent.prototype.onPromoSectionShown = function(animation) {
            this.animationCompleteCounter++;
            this.stopAnimation(animation, "PROMO:SHOWN");
            if (this.animationCompleteCounter >= 2) {
                this.currentState = "PROMO_SHOWS";
                if (this.isHiddingNeeds) this.playPromoSectionHidding();
                else if (!this.isPause) this.promoTimeout = window.setTimeout($bind(this, this.playPromoSectionHidding), this.promoSectionDuration);
            }
        };
        wildFuryAnimation.PromoComponent.prototype.playPromoSectionHidding = function() {
            this.currentState = "PROMO_HIDDING";
            var callback;
            if (!this.isHiddingNeeds) callback = $bind(this, this.playPromoSectionShowing);
            else callback = $bind(this, this.hidePromoAnimation);
            this.animationCompleteCounter = 0;
            this.leftAnimation.addEventListener("PROMO:HIDDEN", (function(f, a1) {
                return function() {
                    f(a1);
                };
            })(callback, this.leftAnimation));
            this.rightAnimation.addEventListener("PROMO:HIDDEN", (function(f1, a11) {
                return function() {
                    f1(a11);
                };
            })(callback, this.rightAnimation));
            this.leftAnimation.gotoAndPlay(false, "hide");
            this.rightAnimation.gotoAndPlay(false, "hide");
        };
        wildFuryAnimation.PromoComponent.prototype.initSideAnimationContainers = function() {
            if (!this.isInitialized) {
                var vbAnimView = wildFuryAnimation.ExternalService.viewBuilderFactory.createView(this.vba);
                var animContainer = this.container.getContainerById("PROMO_HOLDER");
                animContainer.addChildComponent(vbAnimView, "ANIMATION_VIEW");
                this.leftAnimationContainer = vbAnimView.getContainerById("PROMO_ANIMATION_HOLDER_LEFT");
                this.rightAnimationContainer = vbAnimView.getContainerById("PROMO_ANIMATION_HOLDER_RIGHT");
                this.hideAllPromo();
                this.isInitialized = true;
            }
            this.setAnimationContainersPosition();
            this.playPromoSection();
        };
        wildFuryAnimation.PromoComponent.prototype.hideAllSideAnimation = function(animContainer, sideContentName) {
            if (animContainer != null) {
                var _g = 1;
                while (_g < 5) {
                    var i = _g++;
                    var side = animContainer.getVBAnimationById("PROMO_" + i + sideContentName);
                    side.getDisplayObject().setVisible(false);
                }
            }
        };
        wildFuryAnimation.PromoComponent.prototype.hideAllPromo = function() {
            this.hideAllSideAnimation(this.leftAnimationContainer, "L_ANIMATION_CONTENT");
            this.hideAllSideAnimation(this.rightAnimationContainer, "R_ANIMATION_CONTENT");
        };
        wildFuryAnimation.PromoComponent.prototype.configure = function(config) {
            if (config.visible) this.updatePositions(config);
            this.updateVisible(config.visible && this.isEnglishLocale);
        };
        wildFuryAnimation.PromoComponent.prototype.updatePositions = function(config) {
            if (config.leftContainerPosition != null) this.leftContainerPosition = config.leftContainerPosition;
            else this.leftContainerPosition = new displayEngineApi.Point(0, 0);
            if (config.rigthContainerPosition != null) this.rigthContainerPosition = config.rigthContainerPosition;
            else this.rigthContainerPosition = new displayEngineApi.Point(0, 0);
            this.setAnimationContainersPosition();
        };
        wildFuryAnimation.PromoComponent.prototype.setAnimationContainersPosition = function() {
            if (this.leftAnimationContainer != null) this.leftAnimationContainer.getDisplayObject().setPos(this.leftContainerPosition.x, this.leftContainerPosition.y);
            if (this.rightAnimationContainer != null) this.rightAnimationContainer.getDisplayObject().setPos(this.rigthContainerPosition.x, this.rigthContainerPosition.y);
        };
        wildFuryAnimation.PromoComponent.prototype.updateVisible = function(value) {
            if (value != this.isVisible) {
                if (value && this.isActive) this.showAndPlay();
                else this.hidePromoSection();
            }
            this.isVisible = value;
        };
        wildFuryAnimation.PromoComponent.prototype.handleAction = function(animAction) {
            var action = animAction.action;
            switch (action[1]) {
                case 0:
                    this.isPause = false;
                    if (this.isVisible && this.isActive) this.showAndPlay();
                    break;
                case 1:
                    this.hide();
                    break;
                case 2:
                    if (this.isVisible) this.handleAdditionalAction(animAction);
                    break;
            }
        };
        wildFuryAnimation.PromoComponent.prototype.showAndPlay = function() {
            if (this.isVisible) {
                this.show();
                if (this.vba != null) this.createPromoAnimation();
            }
        };
        wildFuryAnimation.PromoComponent.prototype.__class__ = wildFuryAnimation.PromoComponent;
        wildFuryAnimation.ReelFrameComponent = function(container, scalefactor) {
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor);
            this.reelMaskComponent = new wildFuryAnimation.ReelMaskComponent(container, scalefactor);
            this.applyBleedCacheAsBitmapCorrection();
        };
        wildFuryAnimation.ReelFrameComponent = ck_implements(wildFuryAnimation.ReelFrameComponent, wildFuryAnimation.IViewBuilderSetter);
        wildFuryAnimation.ReelFrameComponent.__interfaces__ = [wildFuryAnimation.IViewBuilderSetter];
        wildFuryAnimation.ReelFrameComponent.__name__ = ["wildFuryAnimation", "ReelFrameComponent"];
        wildFuryAnimation.ReelFrameComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.ReelFrameComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.ReelFrameComponent.prototype.reelMaskComponent = null;
        wildFuryAnimation.ReelFrameComponent.prototype.animatedFrame = null;
        wildFuryAnimation.ReelFrameComponent.prototype.applyBleedCacheAsBitmapCorrection = function() {
            var busChanel = wildFuryAnimation.ExternalService.busChanel;
            var cacheHelper = this.uiHelper.getCacheHelper();
            var unCacheAll = function(e) {
                cacheHelper.unCacheAll();
            };
            var cacheBleed = function(e1) {
                cacheHelper.cacheOnly(["bleed"]);
            };
            var updateCacheBleedSybols = function(e2) {
                cacheHelper.unCacheAll();
                cacheHelper.cacheOnly(["bleed"]);
            };
            busChanel.subscribe("reels:startSpin", unCacheAll);
            busChanel.subscribe("reels:spinStopped", cacheBleed);
            busChanel.subscribe("reels:setReelCellsVisibility", updateCacheBleedSybols);
            busChanel.subscribe("reels:setReelPicture", updateCacheBleedSybols);
        };
        wildFuryAnimation.ReelFrameComponent.prototype.handleAdditionalAction = function(animAction) {
            if (_hcmn_.js_Boot.__instanceof(animAction.data, wildFuryAnimationPort.MaskPayload)) this.handleMaskPayload(animAction);
            else if (_hcmn_.js_Boot.__instanceof(animAction.data, wildFuryAnimationPort.ReelFrameFreezeAction)) this.handleAnimationPayload(animAction);
        };
        wildFuryAnimation.ReelFrameComponent.prototype.handleAnimationPayload = function(animAction) {
            wildFuryAnimation.AnimationComponentViewLogic.prototype.handleAdditionalAction.call(this, animAction);
            var _g = animAction.data;
            switch (_hcmn_.Type.enumIndex(_g)) {
                case 0:
                    this.showFrozenFrameAnimation();
                    break;
                case 1:
                    this.stopFrozenFrameAnimation();
                    break;
            }
        };
        wildFuryAnimation.ReelFrameComponent.prototype.handleMaskPayload = function(animAction) {
            var data = animAction.data;
            var _g = data.action;
            switch (_g[1]) {
                case 0:
                    this.reelMaskComponent.showSpinningBleedMask(data.reelMask);
                    break;
                case 1:
                    this.reelMaskComponent.hideSpinningBleedMask();
                    break;
            }
        };
        wildFuryAnimation.ReelFrameComponent.prototype.setViewBuilder = function(value) {
            var _g = this;
            wildFuryAnimation.ExternalService.loadConfig("reel-foreground-assets/reels_animation", function(vba) {
                _g.createAnimatedFrame(vba);
            });
        };
        wildFuryAnimation.ReelFrameComponent.prototype.createAnimatedFrame = function(vba) {
            var vbAnimView = wildFuryAnimation.ExternalService.viewBuilderFactory.createView(vba);
            var animHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
            this.animatedFrame = animHolder.getVBAnimationById("ANIMATION_CONTENT");
            this.animatedFrame.hide();
            this.container.addChildComponent(this.animatedFrame, "ANIMATED_FRAME");
        };
        wildFuryAnimation.ReelFrameComponent.prototype.showFrozenFrameAnimation = function() {
            this.animatedFrame.gotoAndPlay(false, "loop");
            this.container.getDisplayObject().setCacheAsBitmap(false);
        };
        wildFuryAnimation.ReelFrameComponent.prototype.stopFrozenFrameAnimation = function() {
            this.animatedFrame.stop();
            this.animatedFrame.hide();
            this.container.getDisplayObject().setCacheAsBitmap(true);
        };
        wildFuryAnimation.ReelFrameComponent.prototype.__class__ = wildFuryAnimation.ReelFrameComponent;
        wildFuryAnimation.ReelMaskComponent = function(container, scalefactor) {
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor);
            this.waitStageIsPresent($bind(this, this.waitReelsAndApplyMasks));
        };
        wildFuryAnimation.ReelMaskComponent.__name__ = ["wildFuryAnimation", "ReelMaskComponent"];
        wildFuryAnimation.ReelMaskComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.ReelMaskComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.ReelMaskComponent.prototype.layout = null;
        wildFuryAnimation.ReelMaskComponent.prototype.bleed = null;
        wildFuryAnimation.ReelMaskComponent.prototype.waitStageIsPresent = function(calback) {
            var _g = this;
            tools.Await.await(this.getParentIsStageBoolSupplier(), function() {
                calback(_hcmn_.js_Boot.__cast(_g.container.getDisplayObject().getParent(), displayEngineApi.IStage));
            });
        };
        wildFuryAnimation.ReelMaskComponent.prototype.waitReelsAndApplyMasks = function(stage) {
            var _g = this;
            tools.Await.await(this.getChildsIsPresentBoolSupplier(stage, ["layout", "bleed"]), function() {
                _g.layout = stage.getChildByID("layout");
                _g.bleed = stage.getChildByID("bleed");
                _g.applyMasks();
            });
        };
        wildFuryAnimation.ReelMaskComponent.prototype.applyMasks = function() {
            this.uiHelper.addMask(this.bleed, wildFuryAnimation.MaskPoints.TOP_RELL_FRAME_MASK_POINTS, 0, 158);
            this.layout.setCacheAsBitmap(false);
            this.uiHelper.addMask(this.layout, wildFuryAnimation.MaskPoints.RELL_FRAME_MASK_POINTS, 5, 58);
        };
        wildFuryAnimation.ReelMaskComponent.prototype.getParentIsStageBoolSupplier = function() {
            var _g = this;
            return function() {
                return _hcmn_.Std["is"](_g.container.getDisplayObject().getParent(), displayEngineApi.IStage);
            };
        };
        wildFuryAnimation.ReelMaskComponent.prototype.getChildsIsPresentBoolSupplier = function(stage, childs) {
            var _g = this;
            return function() {
                return _g.isChildsPresent(stage, childs);
            };
        };
        wildFuryAnimation.ReelMaskComponent.prototype.isChildsPresent = function(stage, childs) {
            var _g = 0;
            while (_g < childs.length) {
                var childName = childs[_g];
                ++_g;
                if (stage.getChildByID(childName) == null) return false;
            }
            return true;
        };
        wildFuryAnimation.ReelMaskComponent.prototype.showSpinningBleedMask = function(reelMask) {
            if (this.bleed != null) this.uiHelper.addMask(this.bleed, wildFuryAnimation.MaskPoints.getReelMask(reelMask), 5, 58);
        };
        wildFuryAnimation.ReelMaskComponent.prototype.hideSpinningBleedMask = function() {
            this.uiHelper.addMask(this.bleed, wildFuryAnimation.MaskPoints.TOP_RELL_FRAME_MASK_POINTS, 0, 158);
        };
        wildFuryAnimation.ReelMaskComponent.prototype.__class__ = wildFuryAnimation.ReelMaskComponent;
        wildFuryAnimation.TensionComponent = function(container, scalefactor, isAnimated) {
            if (isAnimated == null) isAnimated = true;
            this.gap = 0.0;
            wildFuryAnimation.AnimationComponentViewLogic.call(this, container, scalefactor, true);
        };
        wildFuryAnimation.TensionComponent = ck_implements(wildFuryAnimation.TensionComponent, wildFuryAnimation.IViewBuilderSetter);
        wildFuryAnimation.TensionComponent.__interfaces__ = [wildFuryAnimation.IViewBuilderSetter];
        wildFuryAnimation.TensionComponent.__name__ = ["wildFuryAnimation", "TensionComponent"];
        wildFuryAnimation.TensionComponent.__super__ = wildFuryAnimation.AnimationComponentViewLogic;
        for (var k in wildFuryAnimation.AnimationComponentViewLogic.prototype) wildFuryAnimation.TensionComponent.prototype[k] = wildFuryAnimation.AnimationComponentViewLogic.prototype[k];
        wildFuryAnimation.TensionComponent.prototype.config = null;
        wildFuryAnimation.TensionComponent.prototype.animation = null;
        wildFuryAnimation.TensionComponent.prototype.gap = null;
        wildFuryAnimation.TensionComponent.prototype.currentReelId = null;
        wildFuryAnimation.TensionComponent.prototype.handleAction = function(action, reelId) {
            if (action == wildFuryAnimationPort.Action.SHOW) {
                this.show();
                this.createAnimations();
                this.playAnimation(reelId);
            } else this.hide();
        };
        wildFuryAnimation.TensionComponent.prototype.hide = function() {
            wildFuryAnimation.AnimationComponentViewLogic.prototype.hide.call(this);
            if (this.animation != null) {
                this.animation.stop();
                this.animation.dispose();
                this.container.disposeChildComponent("TENSION_FRAME");
                this.animation = null;
            }
        };
        wildFuryAnimation.TensionComponent.prototype.createAnimations = function() {
            if (this.animation == null) {
                var animHolder = this.container.createContainerFromStoredConfig("ANIMATION_HOLDER");
                this.animation = animHolder.getVBAnimationById("ANIMATION_CONTENT");
                this.container.addChildComponent(this.animation, "TENSION_FRAME");
            }
        };
        wildFuryAnimation.TensionComponent.prototype.playAnimation = function(reelId) {
            this.currentReelId = reelId;
            this.animation.getDisplayObject().setPos((this.config.paddingX + this.config.width + this.gap) * reelId, this.config.paddingY);
            this.animation.play(false);
        };
        wildFuryAnimation.TensionComponent.prototype.setPosition = function(symbolContainer, col) {};
        wildFuryAnimation.TensionComponent.prototype.action = function(animAction) {
            this.handleAction(animAction.action, animAction.data);
        };
        wildFuryAnimation.TensionComponent.prototype.show = function() {
            this.container.show();
        };
        wildFuryAnimation.TensionComponent.prototype.configure = function(layoutConfig) {
            wildFuryAnimation.AnimationComponentViewLogic.prototype.configure.call(this, layoutConfig);
            if (layoutConfig != null) this.gap = layoutConfig.gap;
            else this.gap = 0;
            if (this.animation != null) this.animation.getDisplayObject().setPos((this.config.paddingX + this.config.width + this.gap) * this.currentReelId, this.config.paddingY);
        };
        wildFuryAnimation.TensionComponent.prototype.setViewBuilder = function(value) {
            var _g = this;
            wildFuryAnimation.ExternalService.loadConfig("tension-assets/tension_config", function(data) {
                _g.config = data;
            });
        };
        wildFuryAnimation.TensionComponent.prototype.__class__ = wildFuryAnimation.TensionComponent;
        wildFuryAnimation.DragonVfxConfig = function() {};
        wildFuryAnimation.DragonVfxConfig.__name__ = ["wildFuryAnimation", "DragonVfxConfig"];
        wildFuryAnimation.DragonVfxConfig.prototype.scaleRelativeElement = null;
        wildFuryAnimation.DragonVfxConfig.prototype.scale = null;
        wildFuryAnimation.DragonVfxConfig.prototype.timeDuration = null;
        wildFuryAnimation.DragonVfxConfig.prototype.numberOfImposition = null;
        wildFuryAnimation.DragonVfxConfig.prototype.defaultFps = null;
        wildFuryAnimation.DragonVfxConfig.prototype.initialDragonLengths = null;
        wildFuryAnimation.DragonVfxConfig.prototype.__class__ = wildFuryAnimation.DragonVfxConfig;
        if (typeof components == 'undefined') {
            var components = {};
        };
        if (!components.animation) {
            components.animation = {};
        };
        if (!components.animation.config) {
            components.animation.config = {};
        };
        components.animation.config.DragonsConfig = function() {};
        components.animation.config.DragonsConfig.__name__ = ["components", "animation", "config", "DragonsConfig"];
        components.animation.config.DragonsConfig.prototype.scale = null;
        components.animation.config.DragonsConfig.prototype.goldDragon = null;
        components.animation.config.DragonsConfig.prototype.blueDragon = null;
        components.animation.config.DragonsConfig.prototype.horizontalGoldDragon = null;
        components.animation.config.DragonsConfig.prototype.horizontalBlueDragon = null;
        components.animation.config.DragonsConfig.prototype.tauntHorizontalBlueDragon = null;
        components.animation.config.DragonsConfig.prototype.tauntHorizontalGoldDragon = null;
        components.animation.config.DragonsConfig.prototype.__class__ = components.animation.config.DragonsConfig;
        wildFuryAnimation.FlyingSymbolsConfig = function() {};
        wildFuryAnimation.FlyingSymbolsConfig.__name__ = ["wildFuryAnimation", "FlyingSymbolsConfig"];
        wildFuryAnimation.FlyingSymbolsConfig.prototype.cellWidth = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.cellHeight = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.symbols = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.delayBeforeStart = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.delayBeforeNext = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.animationBasicTime = null;
        wildFuryAnimation.FlyingSymbolsConfig.prototype.__class__ = wildFuryAnimation.FlyingSymbolsConfig;
        wildFuryAnimation.DataProvider = function(dataSupplier) {
            this.dataSupplier = dataSupplier;
        };
        wildFuryAnimation.DataProvider.__name__ = ["wildFuryAnimation", "DataProvider"];
        wildFuryAnimation.DataProvider.prototype.dataSupplier = null;
        wildFuryAnimation.DataProvider.prototype.getDataProvider = function() {
            return this.dataSupplier();
        };
        wildFuryAnimation.DataProvider.prototype.__class__ = wildFuryAnimation.DataProvider;
        wildFuryAnimation.DragonsWays = function() {
            this.pi = _hcmn_.Math.PI;
            this.animationIndex = 0;
            this.collectWaysGenerators();
        };
        wildFuryAnimation.DragonsWays.__name__ = ["wildFuryAnimation", "DragonsWays"];
        wildFuryAnimation.DragonsWays.prototype.goldDragonWayGenerator = null;
        wildFuryAnimation.DragonsWays.prototype.blueDragonWayGenerator = null;
        wildFuryAnimation.DragonsWays.prototype.goldDragonHorizontalWayGenerator = null;
        wildFuryAnimation.DragonsWays.prototype.blueDragonHorizontalWayGenerator = null;
        wildFuryAnimation.DragonsWays.prototype.animationIndex = null;
        wildFuryAnimation.DragonsWays.prototype.pi = null;
        wildFuryAnimation.DragonsWays.prototype.updateActualWayIndex = function() {
            this.animationIndex = _hcmn_.Std.random(this.goldDragonWayGenerator.length);
        };
        wildFuryAnimation.DragonsWays.prototype.setActualWayIndex = function(value) {
            this.animationIndex = value;
        };
        wildFuryAnimation.DragonsWays.prototype.collectWaysGenerators = function() {
            var _g = this;
            this.goldDragonWayGenerator = [];
            this.blueDragonWayGenerator = [];
            this.goldDragonHorizontalWayGenerator = [];
            this.blueDragonHorizontalWayGenerator = [];
            this.goldDragonWayGenerator.push(function(value) {
                var x = value * _g.pi;
                var x1 = _g.sin(x * 1.1 + _g.pi / 2) / 3.3 + .6;
                var y = _g.abs(value - 1);
                return new wildFuryAnimation.Point3D(x1, y);
            });
            this.blueDragonWayGenerator.push(function(value1) {
                var x2 = value1 * _g.pi;
                var x3 = _g.abs(_g.sin(x2 * 1.1 + _g.pi / 2) / 3.3 - .6) - .2;
                var y1 = _g.abs(value1 - 1);
                return new wildFuryAnimation.Point3D(x3, y1);
            });
            this.goldDragonHorizontalWayGenerator.push(function(value2) {
                var actualX = value2 * _g.pi;
                var x4 = _g.abs(value2 - 1);
                var z = 1 + _g.sin(x4 * 40) / 10;
                var y2 = -_g.sin(x4 * 4 * _g.pi) / 20 + 0.166666666666666657;
                return new wildFuryAnimation.Point3D(x4, y2, z);
            });
            this.blueDragonHorizontalWayGenerator.push(function(value3) {
                var actualX1 = value3 * _g.pi;
                var x5 = value3;
                var z1 = 1 + _g.sin(x5 * 40) / 10;
                var y3 = -_g.sin(x5 * 4 * _g.pi) / 20 + 0.166666666666666657;
                return new wildFuryAnimation.Point3D(x5, y3, z1);
            });
            this.goldDragonHorizontalWayGenerator.push(function(value4) {
                var x6 = value4;
                var z2 = _g.sin(x6 * 40) / 20 + (1 + x6) * (1 + x6);
                var y4 = -_g.pow(x6 * 1.2 - 0.5, 2) + 0.85;
                x6 = x6 * x6 * 2;
                return new wildFuryAnimation.Point3D(x6, y4, z2);
            });
            this.blueDragonHorizontalWayGenerator.push(function(value5) {
                var x7 = _g.abs(value5 - 1);
                var y5 = -_g.pow(x7 * 1.2 - 0.5, 2) + 0.85;
                var z3 = _g.sin(x7 * 40) / 20 + (1 + x7) * (1 + x7);
                x7 = x7 * x7 * 2;
                return new wildFuryAnimation.Point3D(x7, y5, z3);
            });
            this.checkAmountOfDragonWaysOnEquals();
        };
        wildFuryAnimation.DragonsWays.prototype.pow = function(x, exp) {
            return _hcmn_.Math.pow(x, exp);
        };
        wildFuryAnimation.DragonsWays.prototype.sin = function(x) {
            return _hcmn_.Math.sin(x);
        };
        wildFuryAnimation.DragonsWays.prototype.abs = function(x) {
            return _hcmn_.Math.abs(x);
        };
        wildFuryAnimation.DragonsWays.prototype.checkAmountOfDragonWaysOnEquals = function() {
            var amountOfGoldenWays = this.goldDragonWayGenerator.length;
            var amountOfBlueWays = this.goldDragonWayGenerator.length;
            if (amountOfGoldenWays != amountOfBlueWays) throw new js._Boot.HaxeError("Amount of Dragon ways should be equals: amountOfGoldenWays:[" + amountOfGoldenWays + "] and amountOfBlueWays:[" + amountOfBlueWays + "]");
        };
        wildFuryAnimation.DragonsWays.prototype.getGoldWayGeneratorProvider = function() {
            var _g = this;
            var result = new wildFuryAnimation.DataProvider(function() {
                return _g.goldDragonWayGenerator[_g.animationIndex];
            });
            return result;
        };
        wildFuryAnimation.DragonsWays.prototype.getBlueWayGeneratorProvider = function() {
            var _g = this;
            var result = new wildFuryAnimation.DataProvider(function() {
                return _g.blueDragonWayGenerator[_g.animationIndex];
            });
            return result;
        };
        wildFuryAnimation.DragonsWays.prototype.getGoldHorizontalWayGeneratorProvider = function() {
            var _g = this;
            var result = new wildFuryAnimation.DataProvider(function() {
                return _g.goldDragonHorizontalWayGenerator[_g.animationIndex];
            });
            return result;
        };
        wildFuryAnimation.DragonsWays.prototype.getBlueHorizontalWayGeneratorProvider = function() {
            var _g = this;
            var result = new wildFuryAnimation.DataProvider(function() {
                return _g.blueDragonHorizontalWayGenerator[_g.animationIndex];
            });
            return result;
        };
        wildFuryAnimation.DragonsWays.prototype.__class__ = wildFuryAnimation.DragonsWays;
        wildFuryAnimation.MaskPoints = function() {};
        wildFuryAnimation.MaskPoints.__name__ = ["wildFuryAnimation", "MaskPoints"];
        wildFuryAnimation.MaskPoints.getReelMask = function(reelMask) {
            var symboWidth = 216;
            var paddingTop = 100;
            var paddingDown = 100;
            var reelHeight = 632;
            var reelFrameMask = wildFuryAnimation.MaskPoints.RELL_FRAME_MASK_POINTS.slice();
            var maskCorrector = new components.animation.data.ReelFrameMaskCorrector(symboWidth, reelHeight, paddingTop, paddingDown);
            return maskCorrector.correct(reelFrameMask, reelMask);
        };
        wildFuryAnimation.MaskPoints.prototype.__class__ = wildFuryAnimation.MaskPoints;
        if (!components.animation.data) {
            components.animation.data = {};
        };
        components.animation.data.ReelFrameMaskCorrector = function(symbolWidth, reelHeight, paddingTop, paddingDown) {
            this.symbolWidth = symbolWidth;
            this.halfSymbolWidth = symbolWidth / 2 | 0;
            this.horizontalLeftSymboPadding = symbolWidth / 10 * 3 | 0;
            this.horizontalRightSymboPadding = symbolWidth / 10 * 7 | 0;
            this.paddingTop = paddingTop;
            this.paddingDown = paddingDown;
            this.bottomReelsPosition = reelHeight + paddingTop;
        };
        components.animation.data.ReelFrameMaskCorrector.__name__ = ["components", "animation", "data", "ReelFrameMaskCorrector"];
        components.animation.data.ReelFrameMaskCorrector.prototype.symbolWidth = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.halfSymbolWidth = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.horizontalLeftSymboPadding = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.horizontalRightSymboPadding = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.paddingTop = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.paddingDown = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.bottomReelsPosition = null;
        components.animation.data.ReelFrameMaskCorrector.prototype.correct = function(reelFrameMask, reelMaskVisability) {
            var previouseTopIndex = 1;
            var _g1 = 0;
            var _g = reelMaskVisability.length;
            while (_g1 < _g) {
                var i = _g1++;
                var _g3 = 0;
                var _g2 = reelMaskVisability[i].length;
                while (_g3 < _g2) {
                    var j = _g3++;
                    if (reelMaskVisability[i][j]) {
                        var x = i * this.symbolWidth;
                        if (j == 0) {
                            var pos = previouseTopIndex;
                            previouseTopIndex += 3;
                            this.putTopPadding(reelFrameMask, pos, x);
                        } else {
                            var pos1 = reelFrameMask.length - 2;
                            this.putDownPadding(reelFrameMask, pos1, x);
                        }
                    }
                }
            }
            return reelFrameMask;
        };
        components.animation.data.ReelFrameMaskCorrector.prototype.putDownPadding = function(reelFrameMask, pos, x) {
            reelFrameMask.splice(pos, 0, [x, this.bottomReelsPosition]);
            reelFrameMask.splice(pos, 0, [x + this.horizontalLeftSymboPadding, this.bottomReelsPosition + this.paddingDown]);
            reelFrameMask.splice(pos, 0, [x + this.horizontalRightSymboPadding, this.bottomReelsPosition + this.paddingDown]);
            reelFrameMask.splice(pos, 0, [x + this.symbolWidth, this.bottomReelsPosition]);
        };
        components.animation.data.ReelFrameMaskCorrector.prototype.putTopPadding = function(reelFrameMask, pos, x) {
            reelFrameMask.splice(pos, 0, [x + this.symbolWidth, this.paddingTop]);
            reelFrameMask.splice(pos, 0, [x + this.horizontalRightSymboPadding, 0]);
            reelFrameMask.splice(pos, 0, [x + this.horizontalLeftSymboPadding, 0]);
            reelFrameMask.splice(pos, 0, [x, this.paddingTop]);
        };
        components.animation.data.ReelFrameMaskCorrector.prototype.__class__ = components.animation.data.ReelFrameMaskCorrector;
        wildFuryAnimation.Point3D = function(x, y, z) {
            if (z == null) z = 1;
            displayEngineApi.Point.call(this, x, y);
            this.z = z;
        };
        wildFuryAnimation.Point3D.__name__ = ["wildFuryAnimation", "Point3D"];
        wildFuryAnimation.Point3D.__super__ = displayEngineApi.Point;
        for (var k in displayEngineApi.Point.prototype) wildFuryAnimation.Point3D.prototype[k] = displayEngineApi.Point.prototype[k];
        wildFuryAnimation.Point3D.prototype.z = null;
        wildFuryAnimation.Point3D.prototype.__class__ = wildFuryAnimation.Point3D;
        wildFuryAnimation.AnimationConfig = function() {};
        wildFuryAnimation.AnimationConfig.__name__ = ["wildFuryAnimation", "AnimationConfig"];
        wildFuryAnimation.AnimationConfig.prototype.colorStart = null;
        wildFuryAnimation.AnimationConfig.prototype.colorEnd = null;
        wildFuryAnimation.AnimationConfig.prototype.__class__ = wildFuryAnimation.AnimationConfig;

        wildFuryAnimation.ParticlePlayer = function() {}
        wildFuryAnimation.ParticlePlayer.prototype = {

            playParticle: function(container, position, additionaConfig) {
                return {
                    arguments: ["*", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };
        wildFuryAnimation.ParticlePlayerFromConfig = function(name) {
            this.isStoped = false;
            this.isInit = false;
            var _g = this;
            this.name = name;
            console.log("ET::ParticlePlayerFromConfig::new");
            wildFuryAnimation.ExternalService.loadConfig("" + name + "_animation_json", function(data) {
                _g.animDef = data;
                _g.checkIsInit();
                console.log("ET::ParticlePlayerFromConfig::" + name + "_animation_json:loaded " + (_g.isInit == null ? "null" : "" + _g.isInit));
            });
            wildFuryAnimation.ExternalService.loadConfig("" + name + "_particles_json", function(data1) {
                _g.config = data1;
                _g.checkIsInit();
                console.log("ET::ParticlePlayerFromConfig::" + name + "_particles_json:loaded " + (_g.isInit == null ? "null" : "" + _g.isInit));
            });
            if (!wildFuryAnimation.ParticlePlayerFromConfig.imgData.exists(name)) wildFuryAnimation.ExternalService.loadConfig("" + name + "_particle_png", function(data2) {
                var value = data2;
                wildFuryAnimation.ParticlePlayerFromConfig.imgData.set(name, value);
                _g.checkIsInit();
                console.log("ET::ParticlePlayerFromConfig::" + name + "_particle_png:loaded " + (_g.isInit == null ? "null" : "" + _g.isInit));
            });
        };
        wildFuryAnimation.ParticlePlayerFromConfig = ck_implements(wildFuryAnimation.ParticlePlayerFromConfig, wildFuryAnimation.ParticlePlayer);
        wildFuryAnimation.ParticlePlayerFromConfig.__interfaces__ = [wildFuryAnimation.ParticlePlayer];
        wildFuryAnimation.ParticlePlayerFromConfig.__name__ = ["wildFuryAnimation", "ParticlePlayerFromConfig"];
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.animDef = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.config = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.isInit = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.callbackF = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.name = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.anim = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.container = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.particles = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.isStoped = null;
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.checkIsInit = function() {
            this.isInit = this.config != null && wildFuryAnimation.ParticlePlayerFromConfig.imgData.exists(this.name) && this.animDef != null;
            if (this.isInit && this.callbackF != null) this.callbackF();
        };
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.playParticle = function(container, position, additionaConfig) {
            var _g = this;
            if (!this.isInit) {
                this.callbackF = function() {
                    _g.playParticle(container, position, additionaConfig);
                };
                return;
            }
            if (this.isStoped) return;
            this.container = container;
            var factory = wildFuryAnimation.ExternalService.displayProvider.getFactory();
            if (!wildFuryAnimation.ParticlePlayerFromConfig.particleBitmaps.exists(this.name)) {
                var value = [this.getBitmap(this.name), this.getBitmap(this.name), this.getBitmap(this.name)];
                wildFuryAnimation.ParticlePlayerFromConfig.particleBitmaps.set(this.name, value);
            }
            if (additionaConfig != null && additionaConfig.colorStart != null) {
                this.config.color.start = additionaConfig.colorStart;
                this.config.color.end = additionaConfig.colorEnd;
            }
            this.particles = factory.createParticleSystem(wildFuryAnimation.ParticlePlayerFromConfig.particleBitmaps.get(this.name), this.name, this.config);
            container.addChild(this.particles);
            this.particles.start(wildFuryAnimation.ExternalService.displayProvider.getDefaultStage());
            this.animDef.anims[0].val = position.x;
            this.animDef.anims[1].val = position.y;
            this.anim = factory.createAnimation("particles_" + this.name, this.particles, this.animDef);
            this.anim.start();
        };
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.stop = function() {
            if (this.anim != null || this.isStoped) {
                this.anim.stop();
                this.particles.stop();
                this.container.removeChild(this.particles);
                var _g = 0;
                var _g1 = this.container.getChildren();
                while (_g < _g1.length) {
                    var bitmap = _g1[_g];
                    ++_g;
                    if (_hcmn_.js_Boot.__instanceof(bitmap, displayEngineApi.IDisplayObjectContainer)) this.container.removeChild(bitmap);
                }
                this.anim = null;
                this.particles = null;
                this.container = null;
            }
            this.isStoped = true;
        };
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.getBitmap = function(name) {
            var factory = wildFuryAnimation.ExternalService.displayProvider.getFactory();
            var bitmap = factory.createBitmap(wildFuryAnimation.ParticlePlayerFromConfig.imgData.get(name));
            bitmap.setName(name);
            return bitmap;
        };
        wildFuryAnimation.ParticlePlayerFromConfig.prototype.__class__ = wildFuryAnimation.ParticlePlayerFromConfig;
        if (typeof haxe == 'undefined') {
            var haxe = {};
        };

        haxe.IMap = function() {}
        haxe.IMap.prototype = {

            get: function(k) {
                return {
                    arguments: ["*"],
                    returns: "null"
                };
            },
            keys: function() {
                return {
                    arguments: [],
                    returns: "null"
                };
            }
        };
        if (!haxe.ds) {
            haxe.ds = {};
        };
        haxe.ds.BalancedTree = function() {};
        haxe.ds.BalancedTree.__name__ = ["haxe", "ds", "BalancedTree"];
        haxe.ds.BalancedTree.prototype.root = null;
        haxe.ds.BalancedTree.prototype.set = function(key, value) {
            this.root = this.setLoop(key, value, this.root);
        };
        haxe.ds.BalancedTree.prototype.get = function(key) {
            var node = this.root;
            while (node != null) {
                var c = this.compare(key, node.key);
                if (c == 0) return node.value;
                if (c < 0) node = node.left;
                else node = node.right;
            }
            return null;
        };
        haxe.ds.BalancedTree.prototype.keys = function() {
            var ret = [];
            this.keysLoop(this.root, ret);
            return _hcmn_.HxOverrides.iter(ret);
        };
        haxe.ds.BalancedTree.prototype.setLoop = function(k, v, node) {
            if (node == null) return new haxe.ds.TreeNode(null, k, v, null);
            var c = this.compare(k, node.key);
            if (c == 0) return new haxe.ds.TreeNode(node.left, k, v, node.right, node == null ? 0 : node._height);
            else if (c < 0) {
                var nl = this.setLoop(k, v, node.left);
                return this.balance(nl, node.key, node.value, node.right);
            } else {
                var nr = this.setLoop(k, v, node.right);
                return this.balance(node.left, node.key, node.value, nr);
            }
        };
        haxe.ds.BalancedTree.prototype.keysLoop = function(node, acc) {
            if (node != null) {
                this.keysLoop(node.left, acc);
                acc.push(node.key);
                this.keysLoop(node.right, acc);
            }
        };
        haxe.ds.BalancedTree.prototype.balance = function(l, k, v, r) {
            var hl;
            if (l == null) hl = 0;
            else hl = l._height;
            var hr;
            if (r == null) hr = 0;
            else hr = r._height;
            if (hl > hr + 2) {
                if ((function($this) {
                        var $r;
                        var _this = l.left;
                        $r = _this == null ? 0 : _this._height;
                        return $r;
                    }(this)) >= (function($this) {
                        var $r;
                        var _this1 = l.right;
                        $r = _this1 == null ? 0 : _this1._height;
                        return $r;
                    }(this))) return new haxe.ds.TreeNode(l.left, l.key, l.value, new haxe.ds.TreeNode(l.right, k, v, r));
                else return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l.left, l.key, l.value, l.right.left), l.right.key, l.right.value, new haxe.ds.TreeNode(l.right.right, k, v, r));
            } else if (hr > hl + 2) {
                if ((function($this) {
                        var $r;
                        var _this2 = r.right;
                        $r = _this2 == null ? 0 : _this2._height;
                        return $r;
                    }(this)) > (function($this) {
                        var $r;
                        var _this3 = r.left;
                        $r = _this3 == null ? 0 : _this3._height;
                        return $r;
                    }(this))) return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l, k, v, r.left), r.key, r.value, r.right);
                else return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l, k, v, r.left.left), r.left.key, r.left.value, new haxe.ds.TreeNode(r.left.right, r.key, r.value, r.right));
            } else return new haxe.ds.TreeNode(l, k, v, r, (hl > hr ? hl : hr) + 1);
        };
        haxe.ds.BalancedTree.prototype.compare = function(k1, k2) {
            return _hcmn_.Reflect.compare(k1, k2);
        };
        haxe.ds.BalancedTree.prototype.__class__ = haxe.ds.BalancedTree;
        haxe.ds.TreeNode = function(l, k, v, r, h) {
            if (h == null) h = -1;
            this.left = l;
            this.key = k;
            this.value = v;
            this.right = r;
            if (h == -1) this._height = ((function($this) {
                var $r;
                var _this = $this.left;
                $r = _this == null ? 0 : _this._height;
                return $r;
            }(this)) > (function($this) {
                var $r;
                var _this1 = $this.right;
                $r = _this1 == null ? 0 : _this1._height;
                return $r;
            }(this)) ? (function($this) {
                var $r;
                var _this2 = $this.left;
                $r = _this2 == null ? 0 : _this2._height;
                return $r;
            }(this)) : (function($this) {
                var $r;
                var _this3 = $this.right;
                $r = _this3 == null ? 0 : _this3._height;
                return $r;
            }(this))) + 1;
            else this._height = h;
        };
        haxe.ds.TreeNode.__name__ = ["haxe", "ds", "TreeNode"];
        haxe.ds.TreeNode.prototype.left = null;
        haxe.ds.TreeNode.prototype.right = null;
        haxe.ds.TreeNode.prototype.key = null;
        haxe.ds.TreeNode.prototype.value = null;
        haxe.ds.TreeNode.prototype._height = null;
        haxe.ds.TreeNode.prototype.__class__ = haxe.ds.TreeNode;
        haxe.ds.EnumValueMap = function() {
            haxe.ds.BalancedTree.call(this);
        };
        haxe.ds.EnumValueMap.__interfaces__ = [haxe.IMap];
        haxe.ds.EnumValueMap.__name__ = ["haxe", "ds", "EnumValueMap"];
        haxe.ds.EnumValueMap.__super__ = haxe.ds.BalancedTree;
        for (var k in haxe.ds.BalancedTree.prototype) haxe.ds.EnumValueMap.prototype[k] = haxe.ds.BalancedTree.prototype[k];
        haxe.ds.EnumValueMap.prototype.compare = function(k1, k2) {
            var d = k1[1] - k2[1];
            if (d != 0) return d;
            var p1 = k1.slice(2);
            var p2 = k2.slice(2);
            if (p1.length == 0 && p2.length == 0) return 0;
            return this.compareArgs(p1, p2);
        };
        haxe.ds.EnumValueMap.prototype.compareArgs = function(a1, a2) {
            var ld = a1.length - a2.length;
            if (ld != 0) return ld;
            var _g1 = 0;
            var _g = a1.length;
            while (_g1 < _g) {
                var i = _g1++;
                var d = this.compareArg(a1[i], a2[i]);
                if (d != 0) return d;
            }
            return 0;
        };
        haxe.ds.EnumValueMap.prototype.compareArg = function(v1, v2) {
            if (_hcmn_.Reflect.isEnumValue(v1) && _hcmn_.Reflect.isEnumValue(v2)) return this.compare(v1, v2);
            else if ((v1 instanceof Array) && v1.__enum__ == null && ((v2 instanceof Array) && v2.__enum__ == null)) return this.compareArgs(v1, v2);
            else return _hcmn_.Reflect.compare(v1, v2);
        };
        haxe.ds.EnumValueMap.prototype.__class__ = haxe.ds.EnumValueMap;
        if (typeof js == 'undefined') {
            var js = {};
        };
        if (!js._Boot) {
            js._Boot = {};
        };
        js._Boot.HaxeError = function(val) {
            Error.call(this);
            this.val = val;
            this.message = String(val);
            if (Error.captureStackTrace) Error.captureStackTrace(this, js._Boot.HaxeError);
        };
        js._Boot.HaxeError.__name__ = ["js", "_Boot", "HaxeError"];
        js._Boot.HaxeError.__super__ = Error;
        for (var k in Error.prototype) js._Boot.HaxeError.prototype[k] = Error.prototype[k];
        js._Boot.HaxeError.prototype.val = null;
        js._Boot.HaxeError.prototype.__class__ = js._Boot.HaxeError;
        wildFuryAnimation.Animation.COMPONENTS = new haxe.ds.EnumValueMap();;
        wildFuryAnimation.ExternalService.loadedAssets = new _hcmn_.haxe_ds_StringMap();;
        wildFuryAnimation.BetPanelAdapatationComponent.POLYGON_STEPS = 15;;
        wildFuryAnimation.BetPanelAdapatationComponent.DESKTOP_CHILDS = ["bp_bar", "INFO_BAR"];;
        wildFuryAnimation.BetPanelAdapatationComponent.DEVICE_CHILDS = ["bp_bet", "bp_open", "bp_bar", "INFO_BAR"];;
        wildFuryAnimation.DragonWayControl.ANIMATION_END_EVENT = "ANIMATION::end";;
        wildFuryAnimation.DragonsComponent.ONE_HUNDRED_AND_EIGHTY_DEGREE = 180;;
        wildFuryAnimation.DragonsComponent.ZERO_DEGREE = 0;;
        wildFuryAnimation.LogoComponent.ANIMATION_END_EVENT = "ANIMATION::end";;
        wildFuryAnimation.PromoComponent.ANIMATIONS_AMOUNT = 2;;
        wildFuryAnimation.PromoComponent.PROMO_SECTIONS_AMOUNT = 5;;
        wildFuryAnimation.PromoComponent.ANIMATION_END_EVENT = "ANIMATION::end";;
        wildFuryAnimation.PromoComponent.MAX_PROMO_INDEX = 5;;
        wildFuryAnimation.PromoComponent.PROMO_SHOWING = "PROMO_SHOWING";;
        wildFuryAnimation.PromoComponent.PROMO_HIDDING = "PROMO_HIDDING";;
        wildFuryAnimation.PromoComponent.PROMO_SHOWN = "PROMO_SHOWS";;
        wildFuryAnimation.PromoComponent.PROMO_HIDDEN = "PROMO_HIDDEN";;
        wildFuryAnimation.MaskPoints.BIG_RELL_FRAME_MASK_POINTS = [
            [0, 0],
            [1500, 0],
            [1500, 1500],
            [0, 1500],
            [0, 0]
        ];;
        wildFuryAnimation.MaskPoints.RELL_FRAME_MASK_POINTS = [
            [0, 100],
            [1080, 100],
            [1080, 732],
            [0, 732],
            [0, 0]
        ];;
        wildFuryAnimation.MaskPoints.WIN_METTER_MASK_POINTS = [
            [0, 0],
            [1125, 0],
            [1125, 677],
            [0, 677],
            [0, 0]
        ];;
        wildFuryAnimation.MaskPoints.TOP_RELL_FRAME_MASK_POINTS = [
            [0, 0],
            [1080, 0],
            [1080, 632],
            [0, 632],
            [0, 0]
        ];;
        wildFuryAnimation.ParticlePlayerFromConfig.imgData = new _hcmn_.haxe_ds_StringMap();;
        wildFuryAnimation.ParticlePlayerFromConfig.particleBitmaps = new _hcmn_.haxe_ds_StringMap();;
        return {
            exports: wildFuryAnimation,
            activator: wildFuryAnimation.Activator
        };
    });
//# sourceURL=wildFuryAnimation.js