define("wolfRunAnimation", ["viewBuilderApi", "componentmodelComponentApi", "translationmanagerApi", "clientkernelLoaderApi", "displayEngineApi", "wolfRunComponentsAnimationDeclaration", "displayEngineUtils", "gameLayoutApi", "clientkernelEventbusApi", "clientkernelModulesApi", "wolfRunComponentsAnimationPort"],
    function(viewBuilderApi, componentmodelComponentApi, translationmanagerApi, clientkernelLoaderApi, displayEngineApi, wolfRunComponentsAnimationDeclaration, displayEngineUtils, gameLayoutApi, clientkernelEventbusApi, clientkernelModulesApi, wolfRunComponentsAnimationPort) {
        "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 haxe == 'undefined') {
            var haxe = {};
        };

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

            get: function(k) {
                return {
                    arguments: ["*"],
                    returns: "null"
                };
            },
            set: function(k, v) {
                return {
                    arguments: ["*", "*"],
                    returns: "void"
                };
            },
            keys: function() {
                return {
                    arguments: [],
                    returns: "null"
                };
            }
        };
        if (!haxe._Int64) {
            haxe._Int64 = {};
        };
        haxe._Int64.___Int64 = function(high, low) {
            this.high = high;
            this.low = low;
        };
        haxe._Int64.___Int64.__name__ = ["haxe", "_Int64", "___Int64"];
        haxe._Int64.___Int64.prototype.high = null;
        haxe._Int64.___Int64.prototype.low = null;
        haxe._Int64.___Int64.prototype.__class__ = haxe._Int64.___Int64;
        if (!haxe.io) {
            haxe.io = {};
        };
        haxe.io.Error = {
            __ename__: ["haxe", "io", "Error"],
            __constructs__: ["Blocked", "Overflow", "OutsideBounds", "Custom"]
        };
        haxe.io.Error.Custom = function(e) {
            var $x = ["Custom", 3, e];
            $x.__enum__ = haxe.io.Error;
            $x.toString = $estr;
            return $x;
        };
        haxe.io.Error.Blocked = ["Blocked", 0];
        haxe.io.Error.Blocked.toString = $estr;
        haxe.io.Error.Blocked.__enum__ = haxe.io.Error;
        haxe.io.Error.Overflow = ["Overflow", 1];
        haxe.io.Error.Overflow.toString = $estr;
        haxe.io.Error.Overflow.__enum__ = haxe.io.Error;
        haxe.io.Error.OutsideBounds = ["OutsideBounds", 2];
        haxe.io.Error.OutsideBounds.toString = $estr;
        haxe.io.Error.OutsideBounds.__enum__ = haxe.io.Error;
        haxe.io.FPHelper = function() {};
        haxe.io.FPHelper.__name__ = ["haxe", "io", "FPHelper"];
        haxe.io.FPHelper.i32ToFloat = function(i) {
            var sign = 1 - (i >>> 31 << 1);
            var exp = i >>> 23 & 255;
            var sig = i & 8388607;
            if (sig == 0 && exp == 0) return 0.0;
            return sign * (1 + _hcmn_.Math.pow(2, -23) * sig) * _hcmn_.Math.pow(2, exp - 127);
        };
        haxe.io.FPHelper.floatToI32 = function(f) {
            if (f == 0) return 0;
            var af;
            if (f < 0) af = -f;
            else af = f;
            var exp = _hcmn_.Math.floor(_hcmn_.Math.log(af) / 0.6931471805599453);
            if (exp < -127) exp = -127;
            else if (exp > 128) exp = 128;
            var sig = _hcmn_.Math.round((af / _hcmn_.Math.pow(2, exp) - 1) * 8388608) & 8388607;
            return (f < 0 ? -2147483648 : 0) | exp + 127 << 23 | sig;
        };
        haxe.io.FPHelper.i64ToDouble = function(low, high) {
            var sign = 1 - (high >>> 31 << 1);
            var exp = (high >> 20 & 2047) - 1023;
            var sig = (high & 1048575) * 4294967296. + (low >>> 31) * 2147483648. + (low & 2147483647);
            if (sig == 0 && exp == -1023) return 0.0;
            return sign * (1.0 + _hcmn_.Math.pow(2, -52) * sig) * _hcmn_.Math.pow(2, exp);
        };
        haxe.io.FPHelper.doubleToI64 = function(v) {
            var i64 = haxe.io.FPHelper.i64tmp;
            if (v == 0) {
                i64.low = 0;
                i64.high = 0;
            } else {
                var av;
                if (v < 0) av = -v;
                else av = v;
                var exp = _hcmn_.Math.floor(_hcmn_.Math.log(av) / 0.6931471805599453);
                var sig;
                var v1 = (av / _hcmn_.Math.pow(2, exp) - 1) * 4503599627370496.;
                sig = _hcmn_.Math.round(v1);
                var sig_l = sig | 0;
                var sig_h = sig / 4294967296.0 | 0;
                i64.low = sig_l;
                i64.high = (v < 0 ? -2147483648 : 0) | exp + 1023 << 20 | sig_h;
            }
            return i64;
        };
        haxe.io.FPHelper.prototype.__class__ = haxe.io.FPHelper;
        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;
        if (!js.html) {
            js.html = {};
        };
        if (!js.html.compat) {
            js.html.compat = {};
        };
        js.html.compat.ArrayBuffer = function(a) {
            if ((a instanceof Array) && a.__enum__ == null) {
                this.a = a;
                this.byteLength = a.length;
            } else {
                var len = a;
                this.a = [];
                var _g = 0;
                while (_g < len) {
                    var i = _g++;
                    this.a[i] = 0;
                }
                this.byteLength = len;
            }
        };
        js.html.compat.ArrayBuffer.__name__ = ["js", "html", "compat", "ArrayBuffer"];
        js.html.compat.ArrayBuffer.prototype.byteLength = null;
        js.html.compat.ArrayBuffer.prototype.a = null;
        js.html.compat.ArrayBuffer.prototype.slice = function(begin, end) {
            return new js.html.compat.ArrayBuffer(this.a.slice(begin, end));
        };
        js.html.compat.ArrayBuffer.sliceImpl = function(begin, end) {
            var u = new Uint8Array(this, begin, end == null ? null : end - begin);
            var result = new ArrayBuffer(u.byteLength);
            var resultArray = new Uint8Array(result);
            resultArray.set(u);
            return result;
        };
        js.html.compat.ArrayBuffer.prototype.__class__ = js.html.compat.ArrayBuffer;
        js.html.compat.DataView = function(buffer, byteOffset, byteLength) {
            this.buf = buffer;
            if (byteOffset == null) this.offset = 0;
            else this.offset = byteOffset;
            if (byteLength == null) this.length = buffer.byteLength - this.offset;
            else this.length = byteLength;
            if (this.offset < 0 || this.length < 0 || this.offset + this.length > buffer.byteLength) throw new js._Boot.HaxeError(haxe.io.Error.OutsideBounds);
        };
        js.html.compat.DataView.__name__ = ["js", "html", "compat", "DataView"];
        js.html.compat.DataView.prototype.buf = null;
        js.html.compat.DataView.prototype.offset = null;
        js.html.compat.DataView.prototype.length = null;
        js.html.compat.DataView.prototype.getInt8 = function(byteOffset) {
            var v = this.buf.a[this.offset + byteOffset];
            if (v >= 128) return v - 256;
            else return v;
        };
        js.html.compat.DataView.prototype.getUint8 = function(byteOffset) {
            return this.buf.a[this.offset + byteOffset];
        };
        js.html.compat.DataView.prototype.getInt16 = function(byteOffset, littleEndian) {
            var v = this.getUint16(byteOffset, littleEndian);
            if (v >= 32768) return v - 65536;
            else return v;
        };
        js.html.compat.DataView.prototype.getUint16 = function(byteOffset, littleEndian) {
            if (littleEndian) return this.buf.a[this.offset + byteOffset] | this.buf.a[this.offset + byteOffset + 1] << 8;
            else return this.buf.a[this.offset + byteOffset] << 8 | this.buf.a[this.offset + byteOffset + 1];
        };
        js.html.compat.DataView.prototype.getInt32 = function(byteOffset, littleEndian) {
            var p = this.offset + byteOffset;
            var a = this.buf.a[p++];
            var b = this.buf.a[p++];
            var c = this.buf.a[p++];
            var d = this.buf.a[p++];
            if (littleEndian) return a | b << 8 | c << 16 | d << 24;
            else return d | c << 8 | b << 16 | a << 24;
        };
        js.html.compat.DataView.prototype.getUint32 = function(byteOffset, littleEndian) {
            var v = this.getInt32(byteOffset, littleEndian);
            if (v < 0) return v + 4294967296.;
            else return v;
        };
        js.html.compat.DataView.prototype.getFloat32 = function(byteOffset, littleEndian) {
            return haxe.io.FPHelper.i32ToFloat(this.getInt32(byteOffset, littleEndian));
        };
        js.html.compat.DataView.prototype.getFloat64 = function(byteOffset, littleEndian) {
            var a = this.getInt32(byteOffset, littleEndian);
            var b = this.getInt32(byteOffset + 4, littleEndian);
            return haxe.io.FPHelper.i64ToDouble(littleEndian ? a : b, littleEndian ? b : a);
        };
        js.html.compat.DataView.prototype.setInt8 = function(byteOffset, value) {
            if (value < 0) this.buf.a[byteOffset + this.offset] = value + 128 & 255;
            else this.buf.a[byteOffset + this.offset] = value & 255;
        };
        js.html.compat.DataView.prototype.setUint8 = function(byteOffset, value) {
            this.buf.a[byteOffset + this.offset] = value & 255;
        };
        js.html.compat.DataView.prototype.setInt16 = function(byteOffset, value, littleEndian) {
            this.setUint16(byteOffset, value < 0 ? value + 65536 : value, littleEndian);
        };
        js.html.compat.DataView.prototype.setUint16 = function(byteOffset, value, littleEndian) {
            var p = byteOffset + this.offset;
            if (littleEndian) {
                this.buf.a[p] = value & 255;
                this.buf.a[p++] = value >> 8 & 255;
            } else {
                this.buf.a[p++] = value >> 8 & 255;
                this.buf.a[p] = value & 255;
            }
        };
        js.html.compat.DataView.prototype.setInt32 = function(byteOffset, value, littleEndian) {
            this.setUint32(byteOffset, value, littleEndian);
        };
        js.html.compat.DataView.prototype.setUint32 = function(byteOffset, value, littleEndian) {
            var p = byteOffset + this.offset;
            if (littleEndian) {
                this.buf.a[p++] = value & 255;
                this.buf.a[p++] = value >> 8 & 255;
                this.buf.a[p++] = value >> 16 & 255;
                this.buf.a[p++] = value >>> 24;
            } else {
                this.buf.a[p++] = value >>> 24;
                this.buf.a[p++] = value >> 16 & 255;
                this.buf.a[p++] = value >> 8 & 255;
                this.buf.a[p++] = value & 255;
            }
        };
        js.html.compat.DataView.prototype.setFloat32 = function(byteOffset, value, littleEndian) {
            this.setUint32(byteOffset, haxe.io.FPHelper.floatToI32(value), littleEndian);
        };
        js.html.compat.DataView.prototype.setFloat64 = function(byteOffset, value, littleEndian) {
            var i64 = haxe.io.FPHelper.doubleToI64(value);
            if (littleEndian) {
                this.setUint32(byteOffset, i64.low);
                this.setUint32(byteOffset, i64.high);
            } else {
                this.setUint32(byteOffset, i64.high);
                this.setUint32(byteOffset, i64.low);
            }
        };
        js.html.compat.DataView.prototype.__class__ = js.html.compat.DataView;
        js.html.compat.Uint8Array = function() {};
        js.html.compat.Uint8Array.__name__ = ["js", "html", "compat", "Uint8Array"];
        js.html.compat.Uint8Array._new = function(arg1, offset, length) {
            var arr;
            if (typeof(arg1) == "number") {
                arr = [];
                var _g = 0;
                while (_g < arg1) {
                    var i = _g++;
                    arr[i] = 0;
                }
                arr.byteLength = arr.length;
                arr.byteOffset = 0;
                arr.buffer = new js.html.compat.ArrayBuffer(arr);
            } else if (_hcmn_.js_Boot.__instanceof(arg1, js.html.compat.ArrayBuffer)) {
                var buffer = arg1;
                if (offset == null) offset = 0;
                if (length == null) length = buffer.byteLength - offset;
                if (offset == 0) arr = buffer.a;
                else arr = buffer.a.slice(offset, offset + length);
                arr.byteLength = arr.length;
                arr.byteOffset = offset;
                arr.buffer = buffer;
            } else if ((arg1 instanceof Array) && arg1.__enum__ == null) {
                arr = arg1.slice();
                arr.byteLength = arr.length;
                arr.byteOffset = 0;
                arr.buffer = new js.html.compat.ArrayBuffer(arr);
            } else throw new js._Boot.HaxeError("TODO " + _hcmn_.Std.string(arg1));
            arr.subarray = js.html.compat.Uint8Array._subarray;
            arr.set = js.html.compat.Uint8Array._set;
            return arr;
        };
        js.html.compat.Uint8Array._set = function(arg, offset) {
            var t = this;
            if (_hcmn_.js_Boot.__instanceof(arg.buffer, js.html.compat.ArrayBuffer)) {
                var a = arg;
                if (arg.byteLength + offset > t.byteLength) throw new js._Boot.HaxeError("set() outside of range");
                var _g1 = 0;
                var _g = arg.byteLength;
                while (_g1 < _g) {
                    var i = _g1++;
                    t[i + offset] = a[i];
                }
            } else if ((arg instanceof Array) && arg.__enum__ == null) {
                var a1 = arg;
                if (a1.length + offset > t.byteLength) throw new js._Boot.HaxeError("set() outside of range");
                var _g11 = 0;
                var _g2 = a1.length;
                while (_g11 < _g2) {
                    var i1 = _g11++;
                    t[i1 + offset] = a1[i1];
                }
            } else throw new js._Boot.HaxeError("TODO");
        };
        js.html.compat.Uint8Array._subarray = function(start, end) {
            var t = this;
            var a = js.html.compat.Uint8Array._new(t.slice(start, end));
            a.byteOffset = start;
            return a;
        };
        js.html.compat.Uint8Array.prototype.__class__ = js.html.compat.Uint8Array;
        if (typeof wolfRunAnimation == 'undefined') {
            var wolfRunAnimation = {};
        };
        wolfRunAnimation.Activator = function(context) {};
        wolfRunAnimation.Activator = ck_implements(wolfRunAnimation.Activator, clientkernelModulesApi.IModuleActivator);
        wolfRunAnimation.Activator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        wolfRunAnimation.Activator.__name__ = ["wolfRunAnimation", "Activator"];
        wolfRunAnimation.Activator.prototype.start = function(context) {
            context.getServiceTracker([viewBuilderApi.IViewBuilderFactory, clientkernelLoaderApi.IAssetRegistry, displayEngineApi.IDisplayProvider]).then(function(context1) {
                wolfRunAnimation.ExternalService.initialize(context1);
                var vbf = context1.getAnyService(viewBuilderApi.IViewBuilderFactory, null);
                wolfRunAnimation.ExternalService.viewBuilderFactory = vbf;
                context1.registerService(new wolfRunAnimation.AnimationFactory(vbf, context1), wolfRunComponentsAnimationDeclaration.AnimationDeclaration, null);
            });
        };
        wolfRunAnimation.Activator.prototype.stop = function(context) {};
        wolfRunAnimation.Activator.main = function() {};
        wolfRunAnimation.Activator.prototype.__class__ = wolfRunAnimation.Activator;
        wolfRunAnimation.Animation = function(context, vbf, cfgId) {
            this.initialized = false;
            this.layoutPayload = null;
            this.vba = null;
            this.vbf = vbf;
            this.cfgId = cfgId;
            this.context = context;
            this.port = context.getImplementedPort(wolfRunComponentsAnimationPort.IAnimationImplementationPort);
            this.layoutPort = context.getUsedPort(gameLayoutApi.IGameLayoutPort);
            this.layoutPort.getUpdateComponentLayout().subscribe($bind(this, this.updateLayout));
            if (cfgId.indexOf("freespin") != -1) {
                wolfRunAnimation.ExternalService.loadVBAssets("freespinbonus-assets/FREE_GAME_INTRO_VB", $bind(this, this.loadMainAsset));
                window.console.log(wolfRunAnimation.ExternalService.loadedAssets);
            } else this.loadMainAsset();
        };
        wolfRunAnimation.Animation.__name__ = ["wolfRunAnimation", "Animation"];
        wolfRunAnimation.Animation.prototype.view = null;
        wolfRunAnimation.Animation.prototype.component = null;
        wolfRunAnimation.Animation.prototype.componentId = null;
        wolfRunAnimation.Animation.prototype.cfgId = null;
        wolfRunAnimation.Animation.prototype.context = null;
        wolfRunAnimation.Animation.prototype.vba = null;
        wolfRunAnimation.Animation.prototype.vbf = null;
        wolfRunAnimation.Animation.prototype.controller = null;
        wolfRunAnimation.Animation.prototype.layoutPayload = null;
        wolfRunAnimation.Animation.prototype.initialized = null;
        wolfRunAnimation.Animation.prototype.port = null;
        wolfRunAnimation.Animation.prototype.layoutPort = null;
        wolfRunAnimation.Animation.prototype.loadMainAsset = function() {
            var _g = this;
            wolfRunAnimation.ExternalService.assetRegistry.getAsset(this.cfgId).getContent().then(function(vba) {
                _g.vba = vba;
                if (!_g.initialized) _g.initialize();
            });
        };
        wolfRunAnimation.Animation.prototype.updateLayout = function(e) {
            this.layoutPayload = e.getPayload();
            if (!this.initialized) this.initialize();
            else {
                this.controller.updateLayout(this.layoutPayload);
                this.layoutPort.getComponentLayoutUpdated().publish(this.context.getInstance());
            }
        };
        wolfRunAnimation.Animation.prototype.initialize = function() {
            if (!this.initialized && this.vba != null && this.layoutPayload != null) {
                this.controller = new wolfRunAnimation.AnimationController(this);
                this.view = this.vbf.createView(this.vba);
                this.registerAllComponents();
                this.controller.init();
                this.controller.updateLayout(this.layoutPayload);
                this.layoutPort.getComponentLayoutUpdated().publish(this.context.getInstance());
                this.initialized = true;
            }
        };
        wolfRunAnimation.Animation.prototype.registerAllComponents = function() {
            var parts = new _hcmn_.List();
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.view.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var compId = $it0.next();
                var comp = this.idToComponentEnum(compId);
                if (comp != wolfRunAnimation.ComponentsEnum.NONE) this.registerComponent(comp);
                else parts.add(compId);
            }
            if (!parts.isEmpty()) this.registerCompositeComponent(parts);
        };
        wolfRunAnimation.Animation.prototype.idToComponentEnum = function(id) {
            var ind;
            var _this = _hcmn_.Type.getEnumConstructs(wolfRunAnimation.ComponentsEnum);
            ind = _hcmn_.HxOverrides.indexOf(_this, id, 0);
            if (ind < 0) return wolfRunAnimation.ComponentsEnum.NONE;
            return _hcmn_.Type.createEnum(wolfRunAnimation.ComponentsEnum, id, null);
        };
        wolfRunAnimation.Animation.prototype.registerCompositeComponent = function(parts) {
            if (parts.isEmpty()) return;
            this.component = new wolfRunAnimation.FreeGameAnimation(this.view);
            this.componentId = wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION;
        };
        wolfRunAnimation.Animation.prototype.registerComponent = function(componentEnum) {
            this.component = null;
            switch (componentEnum[1]) {
                case 0:
                    this.registerContainerComponent(wolfRunAnimation.ComponentsEnum.REEL_BACKGROUND, wolfRunAnimation.ReelBackground);
                    break;
                case 1:
                    this.registerContainerComponent(wolfRunAnimation.ComponentsEnum.REEL_FRAMES_CONTAINER, wolfRunAnimation.ReelFrames);
                    break;
                case 2:
                    this.registerContainerComponent(wolfRunAnimation.ComponentsEnum.LOGO, wolfRunAnimation.Logo);
                    break;
                case 3:
                    this.registerContainerComponent(wolfRunAnimation.ComponentsEnum.BANNER, wolfRunAnimation.Banner);
                    break;
                default:
                    return false;
            }
            return true;
        };
        wolfRunAnimation.Animation.prototype.registerContainerComponent = function(componentEnum, componentClass) {
            var container = this.view.getComponentById(componentEnum[0]);
            if (container == null) return;
            this.component = _hcmn_.Type.createInstance(componentClass, [container]);
            this.componentId = componentEnum;
        };
        wolfRunAnimation.Animation.prototype.getComponent = function() {
            return this.component;
        };
        wolfRunAnimation.Animation.prototype.__class__ = wolfRunAnimation.Animation;
        wolfRunAnimation.AnimationController = function(animation) {
            this.flag_addedToStage = false;
            this.animation = animation;
        };
        wolfRunAnimation.AnimationController.__name__ = ["wolfRunAnimation", "AnimationController"];
        wolfRunAnimation.AnimationController.prototype.flag_addedToStage = null;
        wolfRunAnimation.AnimationController.prototype.animation = null;
        wolfRunAnimation.AnimationController.prototype.init = function() {
            this.animation.port.getShow().subscribe($bind(this, this.handleShow));
            this.animation.port.getHide().subscribe($bind(this, this.handleHide));
            this.animation.port.getShowMultiple().subscribe($bind(this, this.handleShowMultiple));
            this.animation.port.getHideMultiple().subscribe($bind(this, this.handleHideMultiple));
            if (this.animation.componentId == wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION) {
                var fgAnimation = this.animation.getComponent();
                fgAnimation.getEvents().ANIMATION_ENDED().addListener($bind(this, this.onFreeGameAnimationComplete));
                fgAnimation.getEvents().BUTTON_CLICKED().addListener($bind(this, this.onFreeGameIntroButtonClicked));
                var bus = wolfRunAnimation.ExternalService.getBus();
                bus.getChannel("GFBus").subscribe("popup:fSIntroFinished", $bind(this, this.autoTestButtonClicked));
            }
        };
        wolfRunAnimation.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 = wolfRunAnimation.ExternalService.displayProvider.getStages();
                stage = this1.get(layerPayload.stage);
                var container;
                container = (function($this) {
                    var $r;
                    var this2 = $this.animation.view.getChildComponents();
                    $r = this2.get(layerId);
                    return $r;
                }(this));
                var containerDO = container.getDisplayObject();
                if (!this.flag_addedToStage) stage.addChild(containerDO);
                containerDO.setX(layerPayload.left);
                containerDO.setY(layerPayload.top);
                containerDO.setScaleX(layerPayload.width / containerDO.getUserData().viewBuilderW);
                containerDO.setScaleY(layerPayload.height / containerDO.getUserData().viewBuilderH);
                containerDO.setZIndex(layerPayload.zIndex);
                if (cfg == null) continue;
                this.animation.getComponent().configure(cfg);
            }
            if (!this.flag_addedToStage) this.flag_addedToStage = true;
        };
        wolfRunAnimation.AnimationController.prototype.onFreeGameAnimationComplete = function(e) {
            this.animation.port.getShown().publishForThis(e);
        };
        wolfRunAnimation.AnimationController.prototype.onFreeGameIntroButtonClicked = function(e) {
            this.animation.port.getTriggered().publishForThis(e);
        };
        wolfRunAnimation.AnimationController.prototype.handleHide = function(e) {
            this.animation.getComponent().hide();
        };
        wolfRunAnimation.AnimationController.prototype.handleShow = function(e) {
            this.animation.getComponent().show(e.getPayload());
        };
        wolfRunAnimation.AnimationController.prototype.autoTestButtonClicked = function(e) {
            if (this.animation.componentId == wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION) this.animation.getComponent().show(new wolfRunComponentsAnimationPort.ShowAnimationPayload("autoTestButtonClicked"));
        };
        wolfRunAnimation.AnimationController.prototype.handleHideMultiple = function(e) {};
        wolfRunAnimation.AnimationController.prototype.handleShowMultiple = function(e) {};
        wolfRunAnimation.AnimationController.prototype.__class__ = wolfRunAnimation.AnimationController;
        wolfRunAnimation.AnimationFactory = function(vbf, context) {
            this.context = context;
            this.vbf = vbf;
        };
        wolfRunAnimation.AnimationFactory = ck_implements(wolfRunAnimation.AnimationFactory, clientkernelModulesApi.IService);
        wolfRunAnimation.AnimationFactory = ck_implements(wolfRunAnimation.AnimationFactory, componentmodelComponentApi.IComponentFactory);
        wolfRunAnimation.AnimationFactory.__interfaces__ = [clientkernelModulesApi.IService, componentmodelComponentApi.IComponentFactory];
        wolfRunAnimation.AnimationFactory.__name__ = ["wolfRunAnimation", "AnimationFactory"];
        wolfRunAnimation.AnimationFactory.prototype.vbf = null;
        wolfRunAnimation.AnimationFactory.prototype.context = null;
        wolfRunAnimation.AnimationFactory.prototype.getComponentDeclaration = function() {
            return wolfRunComponentsAnimationDeclaration.AnimationDeclaration;
        };
        wolfRunAnimation.AnimationFactory.prototype.createComponent = function(context) {
            var cfgId = context.getConfiguration();
            new wolfRunAnimation.Animation(context, this.vbf, cfgId);
        };
        wolfRunAnimation.AnimationFactory.prototype.__class__ = wolfRunAnimation.AnimationFactory;
        wolfRunAnimation.ExternalService = function() {};
        wolfRunAnimation.ExternalService.__name__ = ["wolfRunAnimation", "ExternalService"];
        wolfRunAnimation.ExternalService.displayProvider = null;
        wolfRunAnimation.ExternalService.assetRegistry = null;
        wolfRunAnimation.ExternalService.viewBuilderFactory = null;
        wolfRunAnimation.ExternalService.buss = null;
        wolfRunAnimation.ExternalService.loadedCallback = null;
        wolfRunAnimation.ExternalService.variableRegistry = null;
        wolfRunAnimation.ExternalService.translationManager = null;
        wolfRunAnimation.ExternalService.initialize = function(context) {
            wolfRunAnimation.ExternalService.displayProvider = context.getAnyService(displayEngineApi.IDisplayProvider, null);
            wolfRunAnimation.ExternalService.assetRegistry = context.getAnyService(clientkernelLoaderApi.IAssetRegistry, null);
            wolfRunAnimation.ExternalService.variableRegistry = context.getAnyService(clientkernelLoaderApi.IVariableRegistry, null);
            wolfRunAnimation.ExternalService.buss = context.getAnyService(clientkernelEventbusApi.IEventBus, null);
            wolfRunAnimation.ExternalService.translationManager = context.getAnyService(translationmanagerApi.ITranslationManager);
        };
        wolfRunAnimation.ExternalService.loadVBAssets = function(id, loadedCallback) {
            wolfRunAnimation.ExternalService.loadedCallback = loadedCallback;
            wolfRunAnimation.ExternalService.loading++;
            wolfRunAnimation.ExternalService.assetRegistry.getAsset(id).getContent().then(function(vba) {
                wolfRunAnimation.ExternalService.loadedAssets.set(id, vba);
                wolfRunAnimation.ExternalService.checkLoaded();
            });
        };
        wolfRunAnimation.ExternalService.checkLoaded = function() {
            wolfRunAnimation.ExternalService.totalLoaded++;
            if (wolfRunAnimation.ExternalService.totalLoaded == wolfRunAnimation.ExternalService.loading) wolfRunAnimation.ExternalService.loadedCallback();
        };
        wolfRunAnimation.ExternalService.isMobileGame = function() {
            return wolfRunAnimation.ExternalService.variableRegistry.get("assetPack") == "mobile" || wolfRunAnimation.ExternalService.variableRegistry.get("skin") == "mobile";
        };
        wolfRunAnimation.ExternalService.isTabletGame = function() {
            return wolfRunAnimation.ExternalService.variableRegistry.get("assetPack") == "tablet" || wolfRunAnimation.ExternalService.variableRegistry.get("skin") == "tablet";
        };
        wolfRunAnimation.ExternalService.getBus = function() {
            return wolfRunAnimation.ExternalService.buss;
        };
        wolfRunAnimation.ExternalService.getTranslationService = function() {
            return wolfRunAnimation.ExternalService.translationManager;
        };
        wolfRunAnimation.ExternalService.prototype.__class__ = wolfRunAnimation.ExternalService;

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

            show: function(state) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            configure: function(cfg) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };
        wolfRunAnimation.Banner = function(container) {
            this.isPaused = false;
            this.playingIdleCycle = false;
            this.initialized = false;
            this.currElementIndex = 0;
            var _g = this;
            this.container = container;
            this.messages = [];
            this.bannerPayloads = [];
            this.msgDefinition = new wolfRunAnimation.MessageDefinition();
            container.hide();
            wolfRunAnimation.ExternalService.assetRegistry.getAsset("banner-assets/banner_definition_config.json").getContent().then(function(config) {
                _g.initialize(config);
            });
        };
        wolfRunAnimation.Banner = ck_implements(wolfRunAnimation.Banner, wolfRunAnimation.IAnimationComponent);
        wolfRunAnimation.Banner.__interfaces__ = [wolfRunAnimation.IAnimationComponent];
        wolfRunAnimation.Banner.__name__ = ["wolfRunAnimation", "Banner"];
        wolfRunAnimation.Banner.prototype.msgDefinition = null;
        wolfRunAnimation.Banner.prototype.container = null;
        wolfRunAnimation.Banner.prototype.msgContainer = null;
        wolfRunAnimation.Banner.prototype.messages = null;
        wolfRunAnimation.Banner.prototype.bannerPayloads = null;
        wolfRunAnimation.Banner.prototype.promoFreeSpinsLeftMessage = null;
        wolfRunAnimation.Banner.prototype.idleGroupName = null;
        wolfRunAnimation.Banner.prototype.currElementIndex = null;
        wolfRunAnimation.Banner.prototype.activeTween = null;
        wolfRunAnimation.Banner.prototype.activeProperties = null;
        wolfRunAnimation.Banner.prototype.delayTimer = null;
        wolfRunAnimation.Banner.prototype.initialized = null;
        wolfRunAnimation.Banner.prototype.playingIdleCycle = null;
        wolfRunAnimation.Banner.prototype.isPaused = null;
        wolfRunAnimation.Banner.prototype.setComponentProperties = function(component, elementName) {
            if (!_hcmn_.js_Boot.__instanceof(component, viewBuilderApi.IViewBuilderContainer)) return;
            var container = component;
            if (!this.msgDefinition.ORDER_PROPERTIES.exists(elementName)) return;
            var lang = wolfRunAnimation.ExternalService.variableRegistry.get("language");
            if ((function($this) {
                    var $r;
                    var this1 = $this.msgDefinition.ORDER_PROPERTIES.get(elementName);
                    $r = this1.get(lang);
                    return $r;
                }(this)) == null) lang = "default";
            var orderString;
            var this2 = this.msgDefinition.ORDER_PROPERTIES.get(elementName);
            orderString = this2.get(lang);
            var order = orderString.split("_");
            var tempDO;
            var startPosition = 0.0;
            var _g1 = 0;
            var _g = order.length;
            while (_g1 < _g) {
                var i = _g1++;
                tempDO = ((function($this) {
                    var $r;
                    var this3 = container.getChildComponents();
                    $r = this3.get(order[i]);
                    return $r;
                }(this))).getDisplayObject();
                tempDO.setX(startPosition);
                startPosition += tempDO.getWidth();
            }
        };
        wolfRunAnimation.Banner.prototype.addBannerPayloads = function(component) {
            if (!_hcmn_.js_Boot.__instanceof(component, viewBuilderApi.IViewBuilderContainer)) return;
            var container = component;
            this.bannerPayloads.push([]);
            var $it0 = (function($this) {
                var $r;
                var this1 = container.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                var element;
                var this2 = container.getChildComponents();
                element = this2.get(key);
                if (_hcmn_.js_Boot.__instanceof(element, viewBuilderApi.ILabel)) {
                    var label = element;
                    var bannerPayload = new wolfRunComponentsAnimationPort.BannerPayload(["CENTRAL", 1], label.getText(), key);
                    this.bannerPayloads[this.bannerPayloads.length - 1].push(bannerPayload);
                }
            }
        };
        wolfRunAnimation.Banner.prototype.initialize = function(config) {
            this.msgDefinition.initialize(config);
            this.msgContainer = this.container.getComponentById("MESSAGES");
            this.idleGroupName = this.msgDefinition.GROUPS_ARRAY[0];
            var groupElements = this.msgDefinition.GROUP_ELEMENTS.get(this.idleGroupName);
            var _g = 0;
            while (_g < groupElements.length) {
                var elementName = groupElements[_g];
                ++_g;
                var component = this.msgContainer.getComponentById(elementName);
                this.setComponentProperties(component, elementName);
                this.addBannerPayloads(component);
                var props;
                var this1 = this.msgDefinition.ELEMENT_PROPERTIES.get(this.idleGroupName);
                props = this1.get(elementName);
                displayEngineUtils.TweenX.to(component.getDisplayObject(), props.hidden_properties, null, null, null, null, null, null, null, null, {
                    fileName: "Banner.hx",
                    lineNumber: 132,
                    className: "wolfrun.components.animation.components.Banner",
                    methodName: "initialize"
                });
                this.messages.push(component.getDisplayObject());
            }
            var promoFSGroup = this.msgDefinition.GROUPS_ARRAY[1];
            groupElements = this.msgDefinition.GROUP_ELEMENTS.get(promoFSGroup);
            this.promoFreeSpinsLeftMessage = this.msgContainer.getComponentById(groupElements[0]);
            this.promoFreeSpinsLeftMessage.hide();
            Visibility.change($bind(this, this.handleVisibilityChange));
            this.initialized = true;
        };
        wolfRunAnimation.Banner.prototype.show = function(payload) {
            if (!this.initialized) return;
            if (wolfRunAnimation.ExternalService.isMobileGame() || wolfRunAnimation.ExternalService.isTabletGame()) this.showMobile(payload);
            else this.showDefault(payload);
        };
        wolfRunAnimation.Banner.prototype.showMobile = function(payload) {
            this.container.getComponentById("BKG").hide();
            if (payload.data != null) {
                this.showPromoFSLeft(payload);
                this.msgContainer.show();
                this.container.show();
            } else this.hide();
        };
        wolfRunAnimation.Banner.prototype.showDefault = function(payload) {
            if (payload.data != null) {
                if (this.playingIdleCycle) this.stopIdleCycle();
                this.playingIdleCycle = false;
                this.showPromoFSLeft(payload);
            } else {
                this.promoFreeSpinsLeftMessage.hide();
                if (!this.playingIdleCycle) this.startIdleGroup();
            }
            this.msgContainer.show();
            this.container.show();
        };
        wolfRunAnimation.Banner.prototype.hide = function() {
            if (this.initialized) this.msgContainer.hide();
        };
        wolfRunAnimation.Banner.prototype.configure = function(cfg) {};
        wolfRunAnimation.Banner.prototype.isVisible = function() {
            return window.document.visibilityState == "visible";
        };
        wolfRunAnimation.Banner.prototype.startIdleGroup = function() {
            if (!this.initialized || this.messages.length == 0) return;
            this.currElementIndex = 0;
            this.setCurrentMessageProperties();
            this.playingIdleCycle = true;
            if (!this.isVisible()) {
                this.isPaused = true;
                return;
            }
            this.showCurrentMessage();
            this.delayTimer = _hcmn_.haxe_Timer.delay($bind(this, this.changeMessage), this.activeProperties.duration);
        };
        wolfRunAnimation.Banner.prototype.showPromoFSLeft = function(payload) {
            var data = payload.data;
            var text = wolfRunAnimation.ExternalService.getTranslationService().stringLookup("PromotionalSpinsLeft", [_hcmn_.__map_reserved.promoFreeSpinsLeft != null ? data.getReserved("promoFreeSpinsLeft") : data.h["promoFreeSpinsLeft"]]);
            var label = this.promoFreeSpinsLeftMessage.getComponentById("PromotionalSpinsLeft");
            var bannerPayload = new wolfRunComponentsAnimationPort.BannerPayload(["CENTRAL", 1], text, "PromotionalSpinsLeft");
            label.setText(text);
            this.promoFreeSpinsLeftMessage.show();
            wolfRunAnimation.ExternalService.getBus().getChannel("GFBus").publish("infobar:showBanner", bannerPayload);
        };
        wolfRunAnimation.Banner.prototype.incrementMessageIndex = function() {
            this.currElementIndex++;
            if (this.currElementIndex >= this.messages.length) this.currElementIndex = 0;
        };
        wolfRunAnimation.Banner.prototype.setCurrentMessageProperties = function() {
            var messageId = this.msgDefinition.GROUP_ELEMENTS.get(this.idleGroupName)[this.currElementIndex];
            var this1 = this.msgDefinition.ELEMENT_PROPERTIES.get(this.idleGroupName);
            this.activeProperties = this1.get(messageId);
        };
        wolfRunAnimation.Banner.prototype.hideCurrentMessage = function() {
            displayEngineUtils.TweenX.to(this.messages[this.currElementIndex], this.activeProperties.hidden_properties, null, null, null, null, null, null, null, null, {
                fileName: "Banner.hx",
                lineNumber: 265,
                className: "wolfrun.components.animation.components.Banner",
                methodName: "hideCurrentMessage"
            });
        };
        wolfRunAnimation.Banner.prototype.showCurrentMessage = function() {
            this.activeTween = displayEngineUtils.TweenX.to(this.messages[this.currElementIndex], this.activeProperties.shown_properties, this.activeProperties.transitionIn, _hcmn_.Reflect.field(displayEngineUtils.EaseX, this.activeProperties.easing), null, null, null, null, null, null, {
                fileName: "Banner.hx",
                lineNumber: 270,
                className: "wolfrun.components.animation.components.Banner",
                methodName: "showCurrentMessage"
            });
            if (this.msgContainer.getDisplayObject().getVisible()) {
                var _g = 0;
                var _g1 = this.bannerPayloads[this.currElementIndex];
                while (_g < _g1.length) {
                    var payload = _g1[_g];
                    ++_g;
                    wolfRunAnimation.ExternalService.getBus().getChannel("GFBus").publish("infobar:showBanner", payload);
                }
            }
        };
        wolfRunAnimation.Banner.prototype.changeMessage = function() {
            this.hideCurrentMessage();
            this.incrementMessageIndex();
            this.showCurrentMessage();
            this.delayTimer = _hcmn_.haxe_Timer.delay($bind(this, this.changeMessage), this.activeProperties.duration);
        };
        wolfRunAnimation.Banner.prototype.stopIdleCycle = function() {
            if (this.delayTimer != null) this.delayTimer.stop();
            if (this.activeTween != null) {
                this.activeTween["goto"](this.activeTween.get_totalTime(), false);
                this.activeTween.onFoot(($_ = this.activeTween, $bind($_, $_.stop)));
                this.activeTween.onHead(($_ = this.activeTween, $bind($_, $_.stop)));
                this.activeTween = null;
                this.messages[this.currElementIndex].setAlpha(0);
            }
        };
        wolfRunAnimation.Banner.prototype.handleVisibilityChange = function(e, state) {
            if (!this.playingIdleCycle) return;
            if (state == "hidden") {
                this.stopIdleCycle();
                this.isPaused = true;
            } else if (state == "visible" && this.isPaused) {
                this.delayTimer = _hcmn_.haxe_Timer.delay($bind(this, this.changeMessage), 500);
                this.isPaused = false;
            }
        };
        wolfRunAnimation.Banner.prototype.__class__ = wolfRunAnimation.Banner;

        wolfRunAnimation.IFreeGameAnimation = function() {}
        wolfRunAnimation.IFreeGameAnimation.prototype = {

            getEvents: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        wolfRunAnimation.FreeGameAnimation = function(container) {
            var _g = this;
            this.container = container;
            container.show();
            this._events = new wolfRunAnimation.TransitionScreenEvents();
            wolfRunAnimation.ExternalService.assetRegistry.getAsset("freespinbonus-assets/" + "freespin_messages_config.json").getContent().then(function(config) {
                _g.fsBanner = new wolfRunAnimation.FreeGameBanner(config);
                _g.fsBanner.initMessages(container);
            });
            this.bigBoardContainer = container.getComponentById("FREESPIN_BIGBOARD");
            if (this.bigBoardContainer == null) throw new Error("not found: " + "FREESPIN_BIGBOARD");
            this.startBtnContainer = container.getComponentById("FREESPIN_BUTTON");
            if (this.startBtnContainer == null) throw new Error("not found: " + "FREESPIN_BUTTON");
            this.startBtnContainer.hide();
        };
        wolfRunAnimation.FreeGameAnimation = ck_implements(wolfRunAnimation.FreeGameAnimation, wolfRunAnimation.IFreeGameAnimation);
        wolfRunAnimation.FreeGameAnimation.__interfaces__ = [wolfRunAnimation.IFreeGameAnimation];
        wolfRunAnimation.FreeGameAnimation.__name__ = ["wolfRunAnimation", "FreeGameAnimation"];
        wolfRunAnimation.FreeGameAnimation.prototype.container = null;
        wolfRunAnimation.FreeGameAnimation.prototype._events = null;
        wolfRunAnimation.FreeGameAnimation.prototype.bigBoardContainer = null;
        wolfRunAnimation.FreeGameAnimation.prototype.mainAreaTextHolder = null;
        wolfRunAnimation.FreeGameAnimation.prototype.zoomAnimationHolder = null;
        wolfRunAnimation.FreeGameAnimation.prototype.zoomAnimation = null;
        wolfRunAnimation.FreeGameAnimation.prototype.startBtnContainer = null;
        wolfRunAnimation.FreeGameAnimation.prototype.startBtn = null;
        wolfRunAnimation.FreeGameAnimation.prototype.showPayload = null;
        wolfRunAnimation.FreeGameAnimation.prototype.fsBanner = null;
        wolfRunAnimation.FreeGameAnimation.prototype.startClicked = null;
        wolfRunAnimation.FreeGameAnimation.prototype.clickType = null;
        wolfRunAnimation.FreeGameAnimation.prototype.createZoomAnimation = function() {
            var vbAsset = wolfRunAnimation.ExternalService.loadedAssets.get("freespinbonus-assets/" + ("FREE_GAME_INTRO" + "_VB"));
            if (vbAsset == null) throw new Error("asset not found: " + "freespinbonus-assets/" + ("FREE_GAME_INTRO" + "_VB"));
            var vbAnimView = wolfRunAnimation.ExternalService.viewBuilderFactory.createView(vbAsset);
            if (vbAnimView == null) throw new Error("error on creating view");
            var vbdbAniamtionHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
            this.zoomAnimation = vbdbAniamtionHolder.getComponentById("ANIMATION_CONTENT");
            this.zoomAnimationHolder = this.bigBoardContainer.getComponentById("FREE_GAME_INTRO");
            if (this.zoomAnimationHolder == null) throw new Error("not found: " + "FREE_GAME_INTRO");
            this.zoomAnimationHolder.addChildComponent(this.zoomAnimation, "FREE_GAME_INTRO" + "_VB");
            this.zoomAnimationHolder.hide();
        };
        wolfRunAnimation.FreeGameAnimation.prototype.getIntValueFromPayload = function(key) {
            var data = this.showPayload.data;
            return _hcmn_.__map_reserved[key] != null ? data.getReserved(key) : data.h[key];
        };
        wolfRunAnimation.FreeGameAnimation.prototype.show = function(payload) {
            if (payload.animationId == "autoTestButtonClicked") {
                this.clickType = "_TEST";
                this.onStartClicked(null);
                return;
            }
            this.showPayload = payload;
            var data = this.showPayload.data;
            var _g = payload.animationId;
            switch (_g) {
                case "BonusIntro":
                    this.fsBanner.showIntroMessages(_hcmn_.__map_reserved.FreeSpinsValue != null ? data.getReserved("FreeSpinsValue") : data.h["FreeSpinsValue"], $bind(this, this.showStartButton));
                    break;
                case "UpdateCounter":
                    this.fsBanner.updateCounter(_hcmn_.__map_reserved.current != null ? data.getReserved("current") : data.h["current"], _hcmn_.__map_reserved.total != null ? data.getReserved("total") : data.h["total"]);
                    break;
                case "BonusOutro":
                    this.fsBanner.hideCounter();
                    this.zoomInAnimation();
                    this.setTextLabels("OutroLabels", data);
                    break;
                case "Retrigger":
                    this.zoomInAnimation();
                    this.setTextLabels("RetriggerLabels", data);
                    break;
                case "FreeSpinsLimitReached":
                    var text = wolfRunAnimation.ExternalService.getTranslationService().stringLookup("FreeSpinsLimitIs", [_hcmn_.__map_reserved.total != null ? data.getReserved("total") : data.h["total"]]);
                    if (_hcmn_.__map_reserved.FreeSpinsLimitIs != null) data.setReserved("FreeSpinsLimitIs", text);
                    else data.h["FreeSpinsLimitIs"] = text;
                    this.zoomInAnimation();
                    this.setTextLabels("FSLimitLabels", data);
                    break;
                case "AwardCap":
                    this.fsBanner.hideCounter();
                    break;
                default:
            }
        };
        wolfRunAnimation.FreeGameAnimation.prototype.showStartButton = function() {
            var holder = this.startBtnContainer.getComponentById("START_BONUS_BTN");
            this.startBtn = holder.getComponentById("btn");
            this.startBtn.getEvents().DOWN().addListener($bind(this, this.onStartClicked));
            this.startBtn.show();
            this.startBtnContainer.show();
            this.startClicked = false;
            this.clickType = "";
        };
        wolfRunAnimation.FreeGameAnimation.prototype.onStartClicked = function(e) {
            if (this.startClicked) return;
            this.startClicked = true;
            this._events.BUTTON_CLICKED().dispatch("START_BONUS_BTN" + this.clickType);
            this.startBtn.hide();
            this.startBtnContainer.hide();
            this.fsBanner.stopIntroMessages();
            this.zoomInAnimation();
            this.setTextLabels("IntroLabels", this.showPayload.data);
        };
        wolfRunAnimation.FreeGameAnimation.prototype.setTextLabels = function(containerIdToShow, data) {
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.mainAreaTextHolder.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                var child = this.mainAreaTextHolder.getComponentById(key);
                if (key == containerIdToShow) {
                    this.setLabelData(child, data);
                    child.show();
                } else child.hide();
            }
        };
        wolfRunAnimation.FreeGameAnimation.prototype.setLabelData = function(labels, data) {
            var $it0 = (function($this) {
                var $r;
                var this1 = labels.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                var label = labels.getComponentById(key);
                if ((_hcmn_.__map_reserved[key] != null ? data.getReserved(key) : data.h[key]) != null) {
                    var text = _hcmn_.Std.string(_hcmn_.__map_reserved[key] != null ? data.getReserved(key) : data.h[key]);
                    label.setText(text);
                }
            }
        };
        wolfRunAnimation.FreeGameAnimation.prototype.zoomInAnimation = function() {
            if (this.zoomAnimationHolder == null) this.createZoomAnimation();
            this.zoomAnimationHolder.show();
            this.zoomAnimation.addEventListener("evIntroComplete", $bind(this, this.onZoomInCompleted));
            this.zoomAnimation.gotoAndPlay(false, "intro");
            this.mainAreaTextHolder = this.bigBoardContainer.createContainerFromStoredConfig("FreeGameTextContainer");
            this.bigBoardContainer.addChildComponent(this.mainAreaTextHolder, "textHolder");
            if (this.mainAreaTextHolder == null) throw new Error("not found: " + "FreeGameTextContainer");
            this.mainAreaTextHolder.hide();
        };
        wolfRunAnimation.FreeGameAnimation.prototype.onZoomInCompleted = function() {
            var _g = this;
            this.zoomAnimation.stop();
            this.zoomAnimation.removeEventListener("evIntroComplete");
            this.mainAreaTextHolder.show();
            var delay = this.getIntValueFromPayload("duration");
            if (delay == null) return;
            _hcmn_.haxe_Timer.delay(function() {
                _g.zoomOut();
            }, delay);
        };
        wolfRunAnimation.FreeGameAnimation.prototype.zoomOut = function() {
            this.mainAreaTextHolder.hide();
            this.bigBoardContainer.disposeChildComponent("textHolder");
            this.zoomAnimation.addEventListener("evOutroComplete", $bind(this, this.onZoomOutCompleted));
            this.zoomAnimation.gotoAndPlay(false, "outro");
        };
        wolfRunAnimation.FreeGameAnimation.prototype.onZoomOutCompleted = function() {
            this.zoomAnimation.stop();
            this.zoomAnimation.removeEventListener("evOutroComplete");
            this.zoomAnimation.hide();
            this.zoomAnimationHolder.hide();
            this._events.ANIMATION_ENDED().dispatch("FREE_GAME_INTRO" + ":" + this.showPayload.animationId);
        };
        wolfRunAnimation.FreeGameAnimation.prototype.hide = function() {};
        wolfRunAnimation.FreeGameAnimation.prototype.dispose = function() {};
        wolfRunAnimation.FreeGameAnimation.prototype.getEvents = function() {
            return this._events;
        };
        wolfRunAnimation.FreeGameAnimation.prototype.configure = function(config) {};
        wolfRunAnimation.FreeGameAnimation.prototype.__class__ = wolfRunAnimation.FreeGameAnimation;
        wolfRunAnimation.FreeGameBanner = function(config) {
            this.msgDefinition = new wolfRunAnimation.MessageDefinition();
            this.msgDefinition.initialize(config);
            this.msgs = new _hcmn_.haxe_ds_StringMap();
            this.currMsgGroupName = this.msgDefinition.GROUPS_ARRAY[0];
            this.firstCounterUpdate = true;
        };
        wolfRunAnimation.FreeGameBanner.__name__ = ["wolfRunAnimation", "FreeGameBanner"];
        wolfRunAnimation.FreeGameBanner.prototype.msgContainer = null;
        wolfRunAnimation.FreeGameBanner.prototype.msgs = null;
        wolfRunAnimation.FreeGameBanner.prototype.activeMsg = null;
        wolfRunAnimation.FreeGameBanner.prototype.activeTween = null;
        wolfRunAnimation.FreeGameBanner.prototype.activeProperties = null;
        wolfRunAnimation.FreeGameBanner.prototype.delayTimer = null;
        wolfRunAnimation.FreeGameBanner.prototype.msgDefinition = null;
        wolfRunAnimation.FreeGameBanner.prototype.currMsgGroupName = null;
        wolfRunAnimation.FreeGameBanner.prototype.stopped = null;
        wolfRunAnimation.FreeGameBanner.prototype.firstCounterUpdate = null;
        wolfRunAnimation.FreeGameBanner.prototype.initMessages = function(parent) {
            this.msgContainer = parent.getComponentById("FREESPIN_MESSAGES");
            if (this.msgContainer == null) throw new Error("not found: " + "FREESPIN_MESSAGES");
            this.msgContainer.hide();
            var groupElements = this.msgDefinition.GROUP_ELEMENTS.get(this.currMsgGroupName);
            var _g = 0;
            while (_g < groupElements.length) {
                var elementName = groupElements[_g];
                ++_g;
                var cont = this.msgContainer.getComponentById(elementName);
                var $it0 = (function($this) {
                    var $r;
                    var this1 = cont.getChildComponents();
                    $r = this1.keys();
                    return $r;
                }(this));
                while ($it0.hasNext()) {
                    var child = $it0.next();
                    var label = cont.getComponentById(child);
                    this.msgs.set(elementName, label);
                }
                this.hideMessage(elementName);
            }
        };
        wolfRunAnimation.FreeGameBanner.prototype.showIntroMessages = function(spinsAwarded, callbackFunction) {
            var _g = this;
            this.stopped = false;
            this.firstCounterUpdate = true;
            this.updateMessageText("msgAwarded", "FreeSpinsAwarded", [spinsAwarded]);
            this.showMessage("msgAwarded");
            this.delayTimer = _hcmn_.haxe_Timer.delay(function() {
                _g.changeIntroMessage();
                callbackFunction();
            }, this.activeProperties.duration);
            Visibility.change($bind(this, this.handleVisibilityChange));
            this.msgContainer.show();
        };
        wolfRunAnimation.FreeGameBanner.prototype.stopIntroMessages = function() {
            this.stopped = true;
        };
        wolfRunAnimation.FreeGameBanner.prototype.updateCounter = function(current, total) {
            this.msgContainer.show();
            this.updateMessageText("msgFreeSpinCounter", "FreeSpinCounter", [current, total]);
            if (this.firstCounterUpdate) this.showMessage("msgFreeSpinCounter");
            this.firstCounterUpdate = false;
        };
        wolfRunAnimation.FreeGameBanner.prototype.hideCounter = function() {
            this.hideMessage("msgFreeSpinCounter");
            this.msgContainer.hide();
        };
        wolfRunAnimation.FreeGameBanner.prototype.showMessage = function(id) {
            var obj = this.msgs.get(id).getDisplayObject();
            this.activeMsg = id;
            var this1 = this.msgDefinition.ELEMENT_PROPERTIES.get(this.currMsgGroupName);
            this.activeProperties = this1.get(id);
            this.activeTween = displayEngineUtils.TweenX.to(obj, this.activeProperties.shown_properties, this.activeProperties.transitionIn, _hcmn_.Reflect.field(displayEngineUtils.EaseX, this.activeProperties.easing), null, null, null, null, null, null, {
                fileName: "FreeGameBanner.hx",
                lineNumber: 135,
                className: "wolfrun.components.animation.components.FreeGameBanner",
                methodName: "showMessage"
            });
        };
        wolfRunAnimation.FreeGameBanner.prototype.hideMessage = function(id) {
            var obj = this.msgs.get(id).getDisplayObject();
            var props;
            var this1 = this.msgDefinition.ELEMENT_PROPERTIES.get(this.currMsgGroupName);
            props = this1.get(id);
            displayEngineUtils.TweenX.to(obj, props.hidden_properties, null, null, null, null, null, null, null, null, {
                fileName: "FreeGameBanner.hx",
                lineNumber: 146,
                className: "wolfrun.components.animation.components.FreeGameBanner",
                methodName: "hideMessage"
            });
        };
        wolfRunAnimation.FreeGameBanner.prototype.updateMessageText = function(containerId, textId, fillIn) {
            var text = wolfRunAnimation.ExternalService.getTranslationService().stringLookup(textId, fillIn);
            var label = this.msgs.get(containerId);
            var bannerPayload = new wolfRunComponentsAnimationPort.BannerPayload(["CENTRAL", 1], text, textId);
            wolfRunAnimation.ExternalService.getBus().getChannel("GFBus").publish("infobar:showBanner", bannerPayload);
            label.setText(text);
        };
        wolfRunAnimation.FreeGameBanner.prototype.changeIntroMessage = function() {
            this.hideMessage(this.activeMsg);
            if (!this.stopped) {
                this.updateMessageText("msgPressButton", "PressButtonToStart");
                this.showMessage("msgPressButton");
                this.delayTimer = _hcmn_.haxe_Timer.delay($bind(this, this.changeIntroMessage), this.activeProperties.duration);
            } else this.delayTimer = null;
        };
        wolfRunAnimation.FreeGameBanner.prototype.handleVisibilityChange = function(e, state) {
            if (this.activeMsg == "msgFreeSpinCounter") return;
            if (state == "hidden") {
                if (this.delayTimer != null) this.delayTimer.stop();
                if (this.activeTween != null) {
                    this.activeTween["goto"](this.activeTween.get_totalTime(), false);
                    this.activeTween.onFoot(($_ = this.activeTween, $bind($_, $_.stop)));
                    this.activeTween.onHead(($_ = this.activeTween, $bind($_, $_.stop)));
                    this.activeTween = null;
                }
            } else if (state == "visible") this.delayTimer = _hcmn_.haxe_Timer.delay($bind(this, this.changeIntroMessage), 500);
        };
        wolfRunAnimation.FreeGameBanner.prototype.clear = function() {
            this.msgContainer = null;
            this.msgs = new _hcmn_.haxe_ds_StringMap();
        };
        wolfRunAnimation.FreeGameBanner.prototype.__class__ = wolfRunAnimation.FreeGameBanner;
        wolfRunAnimation.Logo = function(container) {
            this.container = container;
            container.show();
            this.hLogo = container.getComponentById("logo_horizontal").getDisplayObject();
            this.vLogo = container.getComponentById("logo_vertical").getDisplayObject();
            this.companyLogo = container.getComponentById("logo_static").getDisplayObject();
            this.hLogo.setVisible(true);
            this.vLogo.setVisible(false);
            this.companyLogo.setVisible(false);
        };
        wolfRunAnimation.Logo = ck_implements(wolfRunAnimation.Logo, wolfRunAnimation.IAnimationComponent);
        wolfRunAnimation.Logo.__interfaces__ = [wolfRunAnimation.IAnimationComponent];
        wolfRunAnimation.Logo.__name__ = ["wolfRunAnimation", "Logo"];
        wolfRunAnimation.Logo.prototype.container = null;
        wolfRunAnimation.Logo.prototype.hLogo = null;
        wolfRunAnimation.Logo.prototype.vLogo = null;
        wolfRunAnimation.Logo.prototype.companyLogo = null;
        wolfRunAnimation.Logo.prototype.show = function(payload) {
            this.container.show();
        };
        wolfRunAnimation.Logo.prototype.hide = function() {
            this.container.hide();
        };
        wolfRunAnimation.Logo.prototype.configure = function(config) {
            if (config.type == 1) {
                this.hLogo.setVisible(true);
                this.vLogo.setVisible(false);
            } else if (config.type == 2) {
                this.vLogo.setVisible(true);
                this.hLogo.setVisible(false);
            }
            if (config.companyLogo != null) {
                this.companyLogo.setVisible(true);
                var left = config.companyLogo.left;
                var top = config.companyLogo.top;
                this.companyLogo.setX(left);
                this.companyLogo.setY(top);
            } else this.companyLogo.setVisible(false);
        };
        wolfRunAnimation.Logo.prototype.__class__ = wolfRunAnimation.Logo;
        wolfRunAnimation.ReelBackground = function(container) {
            this.container = container;
            this.reelBackground = container.getComponentById("reel_background");
            this.fsReelBackground = container.getComponentById("reel_background_fs");
            container.show();
            this.fsReelBackground.hide();
            container.getDisplayObject().setCacheAsBitmap(true);
        };
        wolfRunAnimation.ReelBackground = ck_implements(wolfRunAnimation.ReelBackground, wolfRunAnimation.IAnimationComponent);
        wolfRunAnimation.ReelBackground.__interfaces__ = [wolfRunAnimation.IAnimationComponent];
        wolfRunAnimation.ReelBackground.__name__ = ["wolfRunAnimation", "ReelBackground"];
        wolfRunAnimation.ReelBackground.prototype.container = null;
        wolfRunAnimation.ReelBackground.prototype.reelBackground = null;
        wolfRunAnimation.ReelBackground.prototype.fsReelBackground = null;
        wolfRunAnimation.ReelBackground.prototype.show = function(state) {
            this.container.getDisplayObject().setCacheAsBitmap(false);
            this.container.show();
            if (state.animationId == "BaseGameReelBackground") {
                this.reelBackground.show();
                this.fsReelBackground.hide();
            } else if (state.animationId == "FreeGameReelBackground") {
                this.reelBackground.hide();
                this.fsReelBackground.show();
            }
            this.container.getDisplayObject().setCacheAsBitmap(true);
        };
        wolfRunAnimation.ReelBackground.prototype.hide = function() {
            this.container.getDisplayObject().setCacheAsBitmap(false);
            this.container.hide();
        };
        wolfRunAnimation.ReelBackground.prototype.configure = function(config) {};
        wolfRunAnimation.ReelBackground.prototype.__class__ = wolfRunAnimation.ReelBackground;
        wolfRunAnimation.ReelFrames = function(container) {
            this.container = container;
            container.show();
            container.getDisplayObject().setCacheAsBitmap(true);
        };
        wolfRunAnimation.ReelFrames = ck_implements(wolfRunAnimation.ReelFrames, wolfRunAnimation.IAnimationComponent);
        wolfRunAnimation.ReelFrames.__interfaces__ = [wolfRunAnimation.IAnimationComponent];
        wolfRunAnimation.ReelFrames.__name__ = ["wolfRunAnimation", "ReelFrames"];
        wolfRunAnimation.ReelFrames.prototype.container = null;
        wolfRunAnimation.ReelFrames.prototype.show = function(state) {
            this.container.getDisplayObject().setCacheAsBitmap(false);
            this.container.show();
            this.container.getDisplayObject().setCacheAsBitmap(true);
        };
        wolfRunAnimation.ReelFrames.prototype.hide = function() {
            this.container.getDisplayObject().setCacheAsBitmap(false);
            this.container.hide();
        };
        wolfRunAnimation.ReelFrames.prototype.configure = function(config) {};
        wolfRunAnimation.ReelFrames.prototype.__class__ = wolfRunAnimation.ReelFrames;
        wolfRunAnimation.MessageDefinition = function() {};
        wolfRunAnimation.MessageDefinition.__name__ = ["wolfRunAnimation", "MessageDefinition"];
        wolfRunAnimation.MessageDefinition.prototype.GROUPS_ARRAY = null;
        wolfRunAnimation.MessageDefinition.prototype.GROUP_PROPERTIES = null;
        wolfRunAnimation.MessageDefinition.prototype.GROUP_ELEMENTS = null;
        wolfRunAnimation.MessageDefinition.prototype.ELEMENT_PROPERTIES = null;
        wolfRunAnimation.MessageDefinition.prototype.ORDER_PROPERTIES = null;
        wolfRunAnimation.MessageDefinition.prototype.initialize = function(config) {
            this.GROUPS_ARRAY = [];
            this.GROUP_PROPERTIES = new _hcmn_.haxe_ds_StringMap();
            this.GROUP_ELEMENTS = new _hcmn_.haxe_ds_StringMap();
            this.ELEMENT_PROPERTIES = new _hcmn_.haxe_ds_StringMap();
            this.ORDER_PROPERTIES = new _hcmn_.haxe_ds_StringMap();
            var _g = 0;
            var _g1 = _hcmn_.Reflect.fields(config.groups);
            while (_g < _g1.length) {
                var element = _g1[_g];
                ++_g;
                this.GROUPS_ARRAY.push(_hcmn_.Reflect.field(config.groups, element));
            }
            var _g2 = 0;
            var _g11 = this.GROUPS_ARRAY;
            while (_g2 < _g11.length) {
                var element1 = _g11[_g2];
                ++_g2;
                var value = _hcmn_.Reflect.getProperty(config, element1);
                this.GROUP_PROPERTIES.set(element1, value);
            }
            var $it0 = this.GROUP_PROPERTIES.keys();
            while ($it0.hasNext()) {
                var key = $it0.next();
                var value1 = [];
                this.GROUP_ELEMENTS.set(key, value1);
                var _g3 = 0;
                var _g12 = _hcmn_.Reflect.fields(this.GROUP_PROPERTIES.get(key).elements);
                while (_g3 < _g12.length) {
                    var element2 = _g12[_g3];
                    ++_g3;
                    this.GROUP_ELEMENTS.get(key).push(_hcmn_.Reflect.getProperty(this.GROUP_PROPERTIES.get(key).elements, element2));
                }
            }
            var $it1 = this.GROUP_ELEMENTS.keys();
            while ($it1.hasNext()) {
                var key1 = $it1.next();
                var value2 = new _hcmn_.haxe_ds_StringMap();
                this.ELEMENT_PROPERTIES.set(key1, value2);
                var _g4 = 0;
                var _g13;
                _g13 = _hcmn_.js_Boot.__cast(this.GROUP_ELEMENTS.get(key1), Array);
                while (_g4 < _g13.length) {
                    var element3 = _g13[_g4];
                    ++_g4;
                    var this1 = this.ELEMENT_PROPERTIES.get(key1);
                    var key2 = element3;
                    var value3 = _hcmn_.Reflect.getProperty(this.GROUP_PROPERTIES.get(key1), element3);
                    this1.set(key2, value3);
                }
            }
            var _g5 = 0;
            var _g14 = _hcmn_.Reflect.fields(config.directions);
            while (_g5 < _g14.length) {
                var message = _g14[_g5];
                ++_g5;
                var value4 = new _hcmn_.haxe_ds_StringMap();
                this.ORDER_PROPERTIES.set(message, value4);
                var _g21 = 0;
                var _g31 = _hcmn_.Reflect.fields(config.directions[message]);
                while (_g21 < _g31.length) {
                    var lang = _g31[_g21];
                    ++_g21;
                    var this2 = this.ORDER_PROPERTIES.get(message);
                    this2.set(lang, config.directions[message][lang]);
                }
            }
        };
        wolfRunAnimation.MessageDefinition.prototype.__class__ = wolfRunAnimation.MessageDefinition;
        wolfRunAnimation.ComponentsEnum = {
            __ename__: ["wolfRunAnimation", "ComponentsEnum"],
            __constructs__: ["REEL_BACKGROUND", "REEL_FRAMES_CONTAINER", "LOGO", "BANNER", "FREE_SPIN_ANIMATION", "NONE"]
        };
        wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION = ["FREE_SPIN_ANIMATION", 4];
        wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION.toString = $estr;
        wolfRunAnimation.ComponentsEnum.FREE_SPIN_ANIMATION.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.ComponentsEnum.REEL_BACKGROUND = ["REEL_BACKGROUND", 0];
        wolfRunAnimation.ComponentsEnum.REEL_BACKGROUND.toString = $estr;
        wolfRunAnimation.ComponentsEnum.REEL_BACKGROUND.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.ComponentsEnum.NONE = ["NONE", 5];
        wolfRunAnimation.ComponentsEnum.NONE.toString = $estr;
        wolfRunAnimation.ComponentsEnum.NONE.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.ComponentsEnum.BANNER = ["BANNER", 3];
        wolfRunAnimation.ComponentsEnum.BANNER.toString = $estr;
        wolfRunAnimation.ComponentsEnum.BANNER.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.ComponentsEnum.LOGO = ["LOGO", 2];
        wolfRunAnimation.ComponentsEnum.LOGO.toString = $estr;
        wolfRunAnimation.ComponentsEnum.LOGO.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.ComponentsEnum.REEL_FRAMES_CONTAINER = ["REEL_FRAMES_CONTAINER", 1];
        wolfRunAnimation.ComponentsEnum.REEL_FRAMES_CONTAINER.toString = $estr;
        wolfRunAnimation.ComponentsEnum.REEL_FRAMES_CONTAINER.__enum__ = wolfRunAnimation.ComponentsEnum;
        wolfRunAnimation.BaseEvent = function() {
            this._signal = new _hcmn_.msignal_Signal1();
        };
        wolfRunAnimation.BaseEvent.__name__ = ["wolfRunAnimation", "BaseEvent"];
        wolfRunAnimation.BaseEvent.prototype._signal = null;
        wolfRunAnimation.BaseEvent.prototype.addListener = function(listener) {
            this._signal.add(listener);
        };
        wolfRunAnimation.BaseEvent.prototype.removeListener = function(listener) {
            this._signal.remove(listener);
        };
        wolfRunAnimation.BaseEvent.prototype.dispatch = function(data) {
            this._signal.dispatch(data);
        };
        wolfRunAnimation.BaseEvent.prototype.__class__ = wolfRunAnimation.BaseEvent;
        wolfRunAnimation.TransitionScreenEvents = function() {
            this.buttonClicked = new wolfRunAnimation.BaseEvent();
            this.animationEnded = new wolfRunAnimation.BaseEvent();
            this.counterFinished = new wolfRunAnimation.BaseEvent();
            this.retriggerStart = new wolfRunAnimation.BaseEvent();
        };
        wolfRunAnimation.TransitionScreenEvents.__name__ = ["wolfRunAnimation", "TransitionScreenEvents"];
        wolfRunAnimation.TransitionScreenEvents.prototype.buttonClicked = null;
        wolfRunAnimation.TransitionScreenEvents.prototype.animationEnded = null;
        wolfRunAnimation.TransitionScreenEvents.prototype.counterFinished = null;
        wolfRunAnimation.TransitionScreenEvents.prototype.retriggerStart = null;
        wolfRunAnimation.TransitionScreenEvents.prototype.BUTTON_CLICKED = function() {
            return this.buttonClicked;
        };
        wolfRunAnimation.TransitionScreenEvents.prototype.ANIMATION_ENDED = function() {
            return this.animationEnded;
        };
        wolfRunAnimation.TransitionScreenEvents.prototype.COUNTER_FINISHED = function() {
            return this.counterFinished;
        };
        wolfRunAnimation.TransitionScreenEvents.prototype.RETRIGGER_START = function() {
            return this.retriggerStart;
        };
        wolfRunAnimation.TransitionScreenEvents.prototype.__class__ = wolfRunAnimation.TransitionScreenEvents; {
            var ArrayBuffer = (Function("return typeof ArrayBuffer != 'undefined' ? ArrayBuffer : null"))() || js.html.compat.ArrayBuffer;
            if (ArrayBuffer.prototype.slice == null) ArrayBuffer.prototype.slice = js.html.compat.ArrayBuffer.sliceImpl;
        };
        var DataView = (Function("return typeof DataView != 'undefined' ? DataView : null"))() || js.html.compat.DataView;
        var Uint8Array = (Function("return typeof Uint8Array != 'undefined' ? Uint8Array : null"))() || js.html.compat.Uint8Array._new;
        haxe.io.FPHelper.i64tmp = (function($this) {
            var $r;
            var x = new haxe._Int64.___Int64(0, 0);
            $r = x;
            return $r;
        }(this));;
        js.html.compat.Uint8Array.BYTES_PER_ELEMENT = 1;;
        wolfRunAnimation.ExternalService.loadedAssets = new _hcmn_.haxe_ds_StringMap();;
        wolfRunAnimation.ExternalService.loading = 0;;
        wolfRunAnimation.ExternalService.totalLoaded = 0;;
        wolfRunAnimation.Banner.DEFINITION_CONFIG_ID = "banner-assets/banner_definition_config.json";;
        wolfRunAnimation.Banner.MESSAGE_CONTAINER_ID = "MESSAGES";;
        wolfRunAnimation.Banner.PROMO_SPINS_COUNTER = "PromotionalSpinsLeft";;
        wolfRunAnimation.FreeGameAnimation.ASSETS_ID = "freespinbonus-assets/";;
        wolfRunAnimation.FreeGameAnimation.MESSAGES_CONFIG_ID = "freespin_messages_config.json";;
        wolfRunAnimation.FreeGameAnimation.BIGBOARD_CONTAINER_ID = "FREESPIN_BIGBOARD";;
        wolfRunAnimation.FreeGameAnimation.BUTTON_CONTAINER_ID = "FREESPIN_BUTTON";;
        wolfRunAnimation.FreeGameAnimation.MESSAGES_CONTAINER_ID = "FREESPIN_MESSAGES";;
        wolfRunAnimation.FreeGameAnimation.BB_TEXTS_CONTAINER_ID = "FreeGameTextContainer";;
        wolfRunAnimation.FreeGameAnimation.BB_ANIMATION_ID = "FREE_GAME_INTRO";;
        wolfRunAnimation.FreeGameAnimation.BB_ANIM_VB = "FREE_GAME_INTRO" + "_VB";;
        wolfRunAnimation.FreeGameAnimation.LABELS_INTRO = "IntroLabels";;
        wolfRunAnimation.FreeGameAnimation.LABELS_OUTRO = "OutroLabels";;
        wolfRunAnimation.FreeGameAnimation.LABELS_RETRIGGER = "RetriggerLabels";;
        wolfRunAnimation.FreeGameAnimation.LABELS_FS_LIMIT = "FSLimitLabels";;
        wolfRunAnimation.FreeGameAnimation.FS_LIMIT = "FreeSpinsLimitIs";;
        wolfRunAnimation.FreeGameAnimation.ANIM_ZOOM_IN = "intro";;
        wolfRunAnimation.FreeGameAnimation.ANIM_ZOOM_OUT = "outro";;
        wolfRunAnimation.FreeGameAnimation.ANIM_ZOOM_IN_DONE = "evIntroComplete";;
        wolfRunAnimation.FreeGameAnimation.ANIM_ZOOM_OUT_DONE = "evOutroComplete";;
        wolfRunAnimation.FreeGameAnimation.START_BUTTON_ID = "START_BONUS_BTN";;
        wolfRunAnimation.FreeGameBanner.MESSAGES_CONTAINER_ID = "FREESPIN_MESSAGES";;
        wolfRunAnimation.FreeGameBanner.MESSAGE_AWARDED = "msgAwarded";;
        wolfRunAnimation.FreeGameBanner.MESSAGE_PRESS_BTN = "msgPressButton";;
        wolfRunAnimation.FreeGameBanner.COUNTER_MESSAGE = "msgFreeSpinCounter";;
        wolfRunAnimation.FreeGameBanner.AWARDED_LABEL_ID = "FreeSpinsAwarded";;
        wolfRunAnimation.FreeGameBanner.PRESS_BUTTON_LABEL_ID = "PressButtonToStart";;
        wolfRunAnimation.FreeGameBanner.COUNTER_LABEL_ID = "FreeSpinCounter";;
        return {
            exports: wolfRunAnimation,
            activator: wolfRunAnimation.Activator
        };
    });
//# sourceURL=wolfRunAnimation.js