define("icyWildsWinLines", ["viewBuilderApi", "icyWildsWinLinesPort", "componentmodelComponentApi", "clientkernelLoaderApi", "slotModelApi", "displayEngineApi", "clientkernelTestableApi", "gameLayoutApi", "clientkernelEventbusApi", "clientkernelModulesApi"],
    function(viewBuilderApi, icyWildsWinLinesPort, componentmodelComponentApi, clientkernelLoaderApi, slotModelApi, displayEngineApi, clientkernelTestableApi, gameLayoutApi, clientkernelEventbusApi, clientkernelModulesApi) {
        "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"
                };
            },
            keys: function() {
                return {
                    arguments: [],
                    returns: "null"
                };
            }
        };
        haxe.Log = function() {};
        haxe.Log.__name__ = ["haxe", "Log"];
        haxe.Log.trace = function(v, infos) {
            _hcmn_.js_Boot.__trace(v, infos);
        };
        haxe.Log.prototype.__class__ = haxe.Log;
        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 icyWildsWinLines == 'undefined') {
            var icyWildsWinLines = {};
        };
        icyWildsWinLines.Activator = function(context) {};
        icyWildsWinLines.Activator = ck_implements(icyWildsWinLines.Activator, clientkernelModulesApi.IModuleActivator);
        icyWildsWinLines.Activator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        icyWildsWinLines.Activator.__name__ = ["icyWildsWinLines", "Activator"];
        icyWildsWinLines.Activator.prototype.start = function(context) {
            context.getServiceTracker([displayEngineApi.IDisplayProvider, clientkernelTestableApi.ITestable, viewBuilderApi.IViewBuilderFactory]).then(function(context1) {
                icyWildsWinLines.ExternalService.initialize(context1);
                var factory = context1.getAnyService(viewBuilderApi.IViewBuilderFactory, null);
                icyWildsWinLines.ExternalService.viewBuilderFactory = factory;
                context1.registerService(new icyWildsWinLines.WinLinesFactory(factory), icyWildsWinLinesPort.WinLinesDeclaration, null);
            });
        };
        icyWildsWinLines.Activator.prototype.stop = function(context) {};
        icyWildsWinLines.Activator.main = function() {};
        icyWildsWinLines.Activator.prototype.__class__ = icyWildsWinLines.Activator;

        icyWildsWinLines.IScatterSymbols = function() {}
        icyWildsWinLines.IScatterSymbols.prototype = {

            showRegular: function(scatterWins, rgPresentation) {
                return {
                    arguments: ["array", "*"],
                    returns: "void"
                };
            },
            showLanding: function(reelPicture, reelStopped) {
                return {
                    arguments: ["array", "number"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        icyWildsWinLines.ITopSymbols = function() {}
        icyWildsWinLines.ITopSymbols.prototype = {

            show: function(winsymbols, outcome, rgPresentation) {
                return {
                    arguments: ["array", "*", "*"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        icyWildsWinLines.IWinFrames = function() {}
        icyWildsWinLines.IWinFrames.prototype = {

            setOutcome: function(outcome, lineTime, loop, rgPresentation) {
                return {
                    arguments: ["*", "number", "boolean", "*"],
                    returns: "void"
                };
            },
            show: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        icyWildsWinLines.IWinLines = function() {}
        icyWildsWinLines.IWinLines.prototype = {

            getDisplayObject: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setVisible: function(visible) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getContainerComponent: function(component) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            }
        };

        icyWildsWinLines.IWinSymbols = function() {}
        icyWildsWinLines.IWinSymbols.prototype = {

            show: function(winsymbols, outcome, rgPresentation) {
                return {
                    arguments: ["array", "*", "*"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };
        icyWildsWinLines.ExternalService = function() {};
        icyWildsWinLines.ExternalService.__name__ = ["icyWildsWinLines", "ExternalService"];
        icyWildsWinLines.ExternalService.displayProvider = null;
        icyWildsWinLines.ExternalService.assetRegistry = null;
        icyWildsWinLines.ExternalService.testableLogger = null;
        icyWildsWinLines.ExternalService.viewBuilderFactory = null;
        icyWildsWinLines.ExternalService.initialize = function(context) {
            icyWildsWinLines.ExternalService.displayProvider = context.getAnyService(displayEngineApi.IDisplayProvider, null);
            icyWildsWinLines.ExternalService.assetRegistry = context.getAnyService(clientkernelLoaderApi.IAssetRegistry, null);
            var testable = context.getAnyService(clientkernelTestableApi.ITestable, null);
            icyWildsWinLines.ExternalService.testableLogger = testable.getLogger(context);
        };
        icyWildsWinLines.ExternalService.loadConfig = function(config_id, configCallback) {
            icyWildsWinLines.ExternalService.assetRegistry.getAsset(config_id).getContent().then(function(data) {
                configCallback(data);
            });
        };
        icyWildsWinLines.ExternalService.prototype.__class__ = icyWildsWinLines.ExternalService;
        icyWildsWinLines.WinLines = function(context, factory) {
            this.initialized = false;
            this.assetsLoaded = false;
            this.vba = null;
            this.context = context;
            this.layoutPort = context.getUsedPort(gameLayoutApi.IGameLayoutPort);
            this.outcomePhasePort = context.getUsedPort(slotModelApi.IOutcomePhasePort);
            this.factory = factory;
            this.port = context.getImplementedPort(icyWildsWinLinesPort.IWinLinesImplementationPort);
            this.baseEvents = new icyWildsWinLines.BaseEvents();
            this.components = new haxe.ds.EnumValueMap();
            this.layoutPort.getUpdateComponentLayout().subscribe($bind(this, this.updateLayout));
            this.controller = new icyWildsWinLines.WinLinesController(this);
            this.loadVBAssets();
        };
        icyWildsWinLines.WinLines = ck_implements(icyWildsWinLines.WinLines, icyWildsWinLines.IWinLines);
        icyWildsWinLines.WinLines.__interfaces__ = [icyWildsWinLines.IWinLines];
        icyWildsWinLines.WinLines.__name__ = ["icyWildsWinLines", "WinLines"];
        icyWildsWinLines.WinLines.prototype.components = null;
        icyWildsWinLines.WinLines.prototype.factory = null;
        icyWildsWinLines.WinLines.prototype.controller = null;
        icyWildsWinLines.WinLines.prototype.vba = null;
        icyWildsWinLines.WinLines.prototype.winAnimationAssets = null;
        icyWildsWinLines.WinLines.prototype.assetsLoaded = null;
        icyWildsWinLines.WinLines.prototype.initialized = null;
        icyWildsWinLines.WinLines.prototype.view = null;
        icyWildsWinLines.WinLines.prototype.layerContainers = null;
        icyWildsWinLines.WinLines.prototype.port = null;
        icyWildsWinLines.WinLines.prototype.context = null;
        icyWildsWinLines.WinLines.prototype.outcomePhasePort = null;
        icyWildsWinLines.WinLines.prototype.baseEvents = null;
        icyWildsWinLines.WinLines.prototype.layoutPayload = null;
        icyWildsWinLines.WinLines.prototype.layoutPort = null;
        icyWildsWinLines.WinLines.prototype.loadVBAssets = function() {
            var _g = this;
            var vb_assets = ["PRINCESS_VB", "HS_LEOPARD_VB", "HS_HERMALINE_VB", "LS_OWL_VB", "HS_RING_VB", "HS_CROWN_VB", "HS_HEART_VB", "HS_BEAR_VB", "LS_J_ZOOM_VB", "LS_10_VB", "LS_Q_ZOOM_VB", "LS_K_ZOOM_VB", "LS_A_ZOOM_VB"];
            icyWildsWinLines.ExternalService.assetRegistry.getAssetsContent(vb_assets).then(function(data) {
                haxe.Log.trace("[mj] winlines-assets pack loaded", {
                    fileName: "WinLines.hx",
                    lineNumber: 104,
                    className: "icywilds.components.winlines.component.imp.WinLines",
                    methodName: "loadVBAssets"
                });
                icyWildsWinLines.ExternalService.loadedAssets = data;
                _g.loadMainAssets();
            });
        };
        icyWildsWinLines.WinLines.prototype.loadMainAssets = function() {
            var _g = this;
            icyWildsWinLines.ExternalService.assetRegistry.getAsset("win_animations").getContent().then(function(vba) {
                _g.vba = vba;
                _g.assetsLoaded = true;
                _g.initialize();
            });
        };
        icyWildsWinLines.WinLines.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());
            }
        };
        icyWildsWinLines.WinLines.prototype.initialize = function() {
            if (this.assetsLoaded && this.layoutPayload != null) {
                this.view = this.factory.createView(this.vba);
                this.registerAllComponents();
                this.controller.init();
                this.controller.updateLayout(this.layoutPayload);
                this.layoutPort.getComponentLayoutUpdated().publish(this.context.getInstance());
                this.initialized = true;
            }
        };
        icyWildsWinLines.WinLines.prototype.registerAllComponents = function() {
            this.layerContainers = this.view.getChildComponents();
            var $it0 = this.layerContainers.keys();
            while ($it0.hasNext()) {
                var layerId = $it0.next();
                var constructorIndex;
                var _this = _hcmn_.Type.getEnumConstructs(icyWildsWinLines.ComponentsEnum);
                constructorIndex = _hcmn_.HxOverrides.indexOf(_this, layerId, 0);
                if (constructorIndex < 0) continue;
                var componentEnum = _hcmn_.Type.createEnum(icyWildsWinLines.ComponentsEnum, layerId, null);
                if (!this.registerComponent(componentEnum, layerId)) continue;
            }
        };
        icyWildsWinLines.WinLines.prototype.registerComponent = function(componentEnum, layerId) {
            switch (componentEnum[1]) {
                case 0:
                    this.registerContainerComponent(icyWildsWinLines.ComponentsEnum.WIN_FRAMES, layerId, icyWildsWinLines.WinFrames);
                    break;
                case 3:
                    this.registerContainerComponent(icyWildsWinLines.ComponentsEnum.TOP_SYMBOLS, layerId, icyWildsWinLines.TopSymbols);
                    break;
                case 2:
                    this.registerContainerComponent(icyWildsWinLines.ComponentsEnum.WIN_SYMBOLS, layerId, icyWildsWinLines.WinSymbols);
                    break;
                case 1:
                    this.registerContainerComponent(icyWildsWinLines.ComponentsEnum.SKATTER_SYMBOLS, layerId, icyWildsWinLines.ScatterSymbols);
                    break;
            }
            return true;
        };
        icyWildsWinLines.WinLines.prototype.registerContainerComponent = function(component, layerId, componentClass) {
            var container = this.view.getComponentById(component[0]);
            if (container == null) return;
            if (componentClass != null) {
                var specificComponent = _hcmn_.Type.createInstance(componentClass, [container, this.baseEvents]);
                this.components.set(component, specificComponent);
            } else this.components.set(component, container);
        };
        icyWildsWinLines.WinLines.prototype.setVisible = function(visible) {
            this.getDisplayObject().setVisible(visible);
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.view.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                var container = this.view.getComponentById(key);
                container.getDisplayObject().setVisible(visible);
            }
        };
        icyWildsWinLines.WinLines.prototype.getDisplayObject = function() {
            return this.view.getDisplayObject();
        };
        icyWildsWinLines.WinLines.prototype.getWinFrames = function() {
            return this.components.get(icyWildsWinLines.ComponentsEnum.WIN_FRAMES);
        };
        icyWildsWinLines.WinLines.prototype.getTopSymbols = function() {
            return this.components.get(icyWildsWinLines.ComponentsEnum.TOP_SYMBOLS);
        };
        icyWildsWinLines.WinLines.prototype.getWinSymbols = function() {
            return this.components.get(icyWildsWinLines.ComponentsEnum.WIN_SYMBOLS);
        };
        icyWildsWinLines.WinLines.prototype.getSkatterSymbols = function() {
            return this.components.get(icyWildsWinLines.ComponentsEnum.SKATTER_SYMBOLS);
        };
        icyWildsWinLines.WinLines.prototype.getContainerComponent = function(component) {
            return this.components.get(component);
        };
        icyWildsWinLines.WinLines.prototype.getBaseEvent = function(id) {
            return this.baseEvents.getEvent(id);
        };
        icyWildsWinLines.WinLines.prototype.__class__ = icyWildsWinLines.WinLines;
        icyWildsWinLines.WinLinesController = function(winLines) {
            this.reelsNum = 5;
            this.cellsNum = 4;
            this.displayPartsReady = false;
            this.cycleFinishedBeforeDisplayParts = false;
            this.totalDisplayParts = 3;
            this.numberOfDisplayedParts = 0;
            this.winLines = winLines;
        };
        icyWildsWinLines.WinLinesController.__name__ = ["icyWildsWinLines", "WinLinesController"];
        icyWildsWinLines.WinLinesController.prototype.winLines = null;
        icyWildsWinLines.WinLinesController.prototype.reelStop = null;
        icyWildsWinLines.WinLinesController.prototype.numberOfDisplayedParts = null;
        icyWildsWinLines.WinLinesController.prototype.totalDisplayParts = null;
        icyWildsWinLines.WinLinesController.prototype.cycleFinishedBeforeDisplayParts = null;
        icyWildsWinLines.WinLinesController.prototype.displayPartsReady = null;
        icyWildsWinLines.WinLinesController.prototype.winInfos = null;
        icyWildsWinLines.WinLinesController.prototype.cellsNum = null;
        icyWildsWinLines.WinLinesController.prototype.reelsNum = null;
        icyWildsWinLines.WinLinesController.prototype.rgPresentation = null;
        icyWildsWinLines.WinLinesController.prototype.init = function() {
            this.winLines.port.getShowOutcome().subscribe($bind(this, this.handleShowOutcome));
            this.winLines.port.getHideOutcome().subscribe($bind(this, this.handleHideOutcome));
            this.winLines.port.getHandleLandingSymbols().subscribe($bind(this, this.handleLandingSymbols));
            this.winLines.port.setVisible().subscribe($bind(this, this.handleSetVisible));
            this.winLines.getBaseEvent(icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED).add($bind(this, this.winLineCycleEnded));
            this.winLines.getBaseEvent(icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN).add($bind(this, this.handleCurrentWinLine));
            this.winLines.getBaseEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).add($bind(this, this.handleDisplayReady));
        };
        icyWildsWinLines.WinLinesController.prototype.handleSetVisible = function(e) {
            this.winLines.setVisible(e.getPayload());
        };
        icyWildsWinLines.WinLinesController.prototype.handleLandingSymbols = function(e) {
            haxe.Log.trace("[LN] handleLandingSymbols: " + _hcmn_.Std.string(e.getPayload().landingSymbols), {
                fileName: "WinLinesController.hx",
                lineNumber: 69,
                className: "icywilds.components.winlines.component.imp.WinLinesController",
                methodName: "handleLandingSymbols"
            });
            var outcomeOptionsPayload = e.getPayload();
            if (outcomeOptionsPayload != null) {
                var reelStopped = outcomeOptionsPayload.reelStopped;
                if (outcomeOptionsPayload.landingSymbols != null && outcomeOptionsPayload.landingSymbols.length > 0) this.winLines.getSkatterSymbols().showLanding(outcomeOptionsPayload.landingSymbols[reelStopped], reelStopped);
            }
        };
        icyWildsWinLines.WinLinesController.prototype.updateLayout = function(layoutPayload) {
            var $it0 = this.winLines.layerContainers.keys();
            while ($it0.hasNext()) {
                var layerId = $it0.next();
                var layerPayload = layoutPayload.containers.get(layerId);
                if (layerPayload == null) continue;
                var stage;
                var this1 = icyWildsWinLines.ExternalService.displayProvider.getStages();
                stage = this1.get(layerPayload.stage);
                var container = this.winLines.layerContainers.get(layerId).getDisplayObject();
                try {
                    stage.removeChild(container);
                } catch (e) {
                    if (e instanceof js._Boot.HaxeError) e = e.val;
                    if (_hcmn_.js_Boot.__instanceof(e, Error)) {} else throw (e);
                }
                stage.addChild(container);
                container.setX(layerPayload.left);
                container.setY(layerPayload.top);
                container.setScaleX(layerPayload.width / container.getUserData().viewBuilderW);
                container.setScaleY(layerPayload.height / container.getUserData().viewBuilderH);
                container.setZIndex(layerPayload.zIndex);
            }
        };
        icyWildsWinLines.WinLinesController.prototype.handleHideOutcome = function(e) {
            this.hideAll();
        };
        icyWildsWinLines.WinLinesController.prototype.handleShowOutcome = function(e) {
            var symbolOffset = 1;
            var outcomeOptionsPayload = e.getPayload();
            haxe.Log.trace("[LN]x winLines.handleShowOutcome", {
                fileName: "WinLinesController.hx",
                lineNumber: 117,
                className: "icywilds.components.winlines.component.imp.WinLinesController",
                methodName: "handleShowOutcome"
            });
            var outcome = outcomeOptionsPayload.spinOutcome;
            this.rgPresentation = outcomeOptionsPayload.rgPresentation;
            var allWinningSymbols = [];
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var i = _g1++;
                var a = [];
                allWinningSymbols.push(a);
                var _g3 = 0;
                var _g2 = this.cellsNum;
                while (_g3 < _g2) {
                    var j = _g3++;
                    a.push(false);
                }
            }
            if (outcome.lineWins != null && outcome.lineWins.length > 0) {
                var _g4 = 0;
                var _g11 = outcome.lineWins;
                while (_g4 < _g11.length) {
                    var lw = _g11[_g4];
                    ++_g4;
                    var _g31 = 0;
                    var _g21 = this.reelsNum;
                    while (_g31 < _g21) {
                        var i1 = _g31++;
                        var _g5 = 0;
                        var _g41 = this.cellsNum;
                        while (_g5 < _g41) {
                            var j1 = _g5++;
                            if (allWinningSymbols[i1][j1] || lw.winPath.reelsInfo[i1][j1 + symbolOffset] == 1) allWinningSymbols[i1][j1] = true;
                        }
                    }
                }
            }
            if (outcome.bonusWins != null && outcome.bonusWins.length > 0) {
                var _g6 = 0;
                var _g12 = outcome.bonusWins;
                while (_g6 < _g12.length) {
                    var bw = _g12[_g6];
                    ++_g6;
                    if (bw.type == "Princess") {
                        var _g32 = 0;
                        var _g22 = this.reelsNum;
                        while (_g32 < _g22) {
                            var i2 = _g32++;
                            var _g51 = 0;
                            var _g42 = this.cellsNum;
                            while (_g51 < _g42) {
                                var j2 = _g51++;
                                if (allWinningSymbols[i2][j2] || bw.winPath.reelsInfo[i2][j2 + symbolOffset] == 1) allWinningSymbols[i2][j2] = true;
                            }
                        }
                    }
                }
            }
            this.cycleFinishedBeforeDisplayParts = false;
            this.displayPartsReady = false;
            this.numberOfDisplayedParts = 0;
            this.handleSkatterSymbols(allWinningSymbols, outcome.scatterWins, this.rgPresentation);
            this.handleWinSymbols(allWinningSymbols, outcome, this.rgPresentation);
            this.handleTopSymbols(allWinningSymbols, outcome, this.rgPresentation);
            this.handleWinFrames(outcome, outcomeOptionsPayload.lineTime, outcomeOptionsPayload.loop, this.rgPresentation);
        };
        icyWildsWinLines.WinLinesController.prototype.winLineCycleEnded = function(data) {
            haxe.Log.trace("::im winLineCycleEnded ", {
                fileName: "WinLinesController.hx",
                lineNumber: 172,
                className: "icywilds.components.winlines.component.imp.WinLinesController",
                methodName: "winLineCycleEnded",
                customParams: [this.displayPartsReady]
            });
            if (this.displayPartsReady) {
                this.winLines.port.getWinLineCycleAnimated().publish(null);
                return;
            } else this.cycleFinishedBeforeDisplayParts = true;
            if (this.rgPresentation.isReg) {
                if (!this.rgPresentation.isHighWin) this.winLines.port.getWinLineCycleAnimated().publish(null);
            }
        };
        icyWildsWinLines.WinLinesController.prototype.handleCurrentWinLine = function(data) {
            this.winLines.port.getCurrentWin().publish(data);
        };
        icyWildsWinLines.WinLinesController.prototype.handleSkatterSymbols = function(allWinningSymbols, scatterWins, rgPresentation) {
            this.winLines.getSkatterSymbols().showRegular(scatterWins, rgPresentation);
        };
        icyWildsWinLines.WinLinesController.prototype.handleTopSymbols = function(winsymbols, outcome, rgPresentation) {
            this.winLines.getTopSymbols().show(winsymbols, outcome, rgPresentation);
        };
        icyWildsWinLines.WinLinesController.prototype.handleWinFrames = function(outcome, lineTime, loop, rgPresentation) {
            var winFrames = this.winLines.getWinFrames();
            winFrames.setOutcome(outcome, lineTime, loop, rgPresentation);
        };
        icyWildsWinLines.WinLinesController.prototype.handleWinSymbols = function(winsymbols, outcome, rgPresentation) {
            this.winLines.getWinSymbols().show(winsymbols, outcome, rgPresentation);
        };
        icyWildsWinLines.WinLinesController.prototype.handleDisplayReady = function(evt) {
            haxe.Log.trace("::im handleDisplayReady winLines.port.getWinSymbolsCreated().publish", {
                fileName: "WinLinesController.hx",
                lineNumber: 210,
                className: "icywilds.components.winlines.component.imp.WinLinesController",
                methodName: "handleDisplayReady",
                customParams: [this.numberOfDisplayedParts, this.totalDisplayParts, evt]
            });
            this.numberOfDisplayedParts++;
            if (this.numberOfDisplayedParts == this.totalDisplayParts) {
                haxe.Log.trace("::im handleDisplayReady winLines.port.getWinSymbolsCreated().publish ----> TOPIC SENT", {
                    fileName: "WinLinesController.hx",
                    lineNumber: 216,
                    className: "icywilds.components.winlines.component.imp.WinLinesController",
                    methodName: "handleDisplayReady"
                });
                this.winLines.port.getWinSymbolsCreated().publish(null);
                this.displayPartsReady = true;
                this.numberOfDisplayedParts = 0;
                if (this.cycleFinishedBeforeDisplayParts) this.winLineCycleEnded(null);
            }
        };
        icyWildsWinLines.WinLinesController.prototype.hideAll = function() {
            this.winLines.getTopSymbols().hide();
            this.winLines.getSkatterSymbols().hide();
            this.winLines.getWinSymbols().hide();
            this.winLines.getWinFrames().hide();
        };
        icyWildsWinLines.WinLinesController.prototype.__class__ = icyWildsWinLines.WinLinesController;
        icyWildsWinLines.WinLinesFactory = function(vbf) {
            this.vbf = vbf;
        };
        icyWildsWinLines.WinLinesFactory = ck_implements(icyWildsWinLines.WinLinesFactory, clientkernelModulesApi.IService);
        icyWildsWinLines.WinLinesFactory = ck_implements(icyWildsWinLines.WinLinesFactory, componentmodelComponentApi.IComponentFactory);
        icyWildsWinLines.WinLinesFactory.__interfaces__ = [clientkernelModulesApi.IService, componentmodelComponentApi.IComponentFactory];
        icyWildsWinLines.WinLinesFactory.__name__ = ["icyWildsWinLines", "WinLinesFactory"];
        icyWildsWinLines.WinLinesFactory.prototype.vbf = null;
        icyWildsWinLines.WinLinesFactory.prototype.getComponentDeclaration = function() {
            return icyWildsWinLinesPort.WinLinesDeclaration;
        };
        icyWildsWinLines.WinLinesFactory.prototype.createComponent = function(context) {
            var _winlines = new icyWildsWinLines.WinLines(context, this.vbf);
        };
        icyWildsWinLines.WinLinesFactory.prototype.__class__ = icyWildsWinLines.WinLinesFactory;
        icyWildsWinLines.ScatterSymbols = function(container, baseEvents) {
            this.totalVisibleSymbols = 0;
            this.reelsNum = 5;
            this.cellsNum = 4;
            this.symbolOffset = 1;
            this.symbolName = "HS_BEAR";
            this.yOffset = -28;
            this.xOffset = -28;
            this.verticalGap = 0;
            this.horisontalGap = 10;
            this.symbolHeight = 205;
            this.symbolWidth = 278;
            this.baseEvents = baseEvents;
            this.container = container;
            this.symbolsAssets = icyWildsWinLines.ExternalService.loadedAssets;
            container.show();
        };
        icyWildsWinLines.ScatterSymbols = ck_implements(icyWildsWinLines.ScatterSymbols, icyWildsWinLines.IScatterSymbols);
        icyWildsWinLines.ScatterSymbols.__interfaces__ = [icyWildsWinLines.IScatterSymbols];
        icyWildsWinLines.ScatterSymbols.__name__ = ["icyWildsWinLines", "ScatterSymbols"];
        icyWildsWinLines.ScatterSymbols.prototype.container = null;
        icyWildsWinLines.ScatterSymbols.prototype.symbolWidth = null;
        icyWildsWinLines.ScatterSymbols.prototype.symbolHeight = null;
        icyWildsWinLines.ScatterSymbols.prototype.horisontalGap = null;
        icyWildsWinLines.ScatterSymbols.prototype.verticalGap = null;
        icyWildsWinLines.ScatterSymbols.prototype.xOffset = null;
        icyWildsWinLines.ScatterSymbols.prototype.yOffset = null;
        icyWildsWinLines.ScatterSymbols.prototype.symbolName = null;
        icyWildsWinLines.ScatterSymbols.prototype.symbolOffset = null;
        icyWildsWinLines.ScatterSymbols.prototype.cellsNum = null;
        icyWildsWinLines.ScatterSymbols.prototype.reelsNum = null;
        icyWildsWinLines.ScatterSymbols.prototype.symbolsAssets = null;
        icyWildsWinLines.ScatterSymbols.prototype.totalVisibleSymbols = null;
        icyWildsWinLines.ScatterSymbols.prototype.baseEvents = null;
        icyWildsWinLines.ScatterSymbols.prototype.showLanding = function(reelPicture, reelStopped) {
            this.container.show();
            var totalSymbols = reelPicture.length;
            var showInOffScreen = false;
            var totalLandings = 0;
            var _g1 = 0;
            var _g = reelPicture.length;
            while (_g1 < _g) {
                var i = _g1++;
                var visible = reelPicture[i];
                if (visible == 1) totalLandings++;
                if (totalLandings > 1) showInOffScreen = true;
            }
            var _g11 = 0;
            var _g2 = reelPicture.length;
            while (_g11 < _g2) {
                var i1 = _g11++;
                var visible1 = reelPicture[i1];
                var id = this.symbolName + "_" + reelStopped + "_" + i1;
                if (visible1 == 1) {
                    if (this.container.getComponentById(id) == null) {
                        var symbolContainer = this.container.createContainerFromStoredConfig(this.symbolName + "_CONTAINER");
                        this.container.addChildComponent(symbolContainer, id);
                        symbolContainer.setX(this.xOffset + (this.symbolWidth + this.horisontalGap) * reelStopped);
                        symbolContainer.setY(this.yOffset + (this.symbolHeight + this.verticalGap) * i1);
                        symbolContainer.show();
                        symbolContainer.getDisplayObject().setVisible(true);
                        var vbAsset = this.symbolsAssets.get(this.symbolName + "_VB");
                        var vbAnimView = icyWildsWinLines.ExternalService.viewBuilderFactory.createView(vbAsset);
                        var vbAnimationHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
                        var vbAnimationComponent;
                        vbAnimationComponent = _hcmn_.js_Boot.__cast(vbAnimationHolder.getComponentById("ANIMATION_CONTENT"), viewBuilderApi.IVBAnimationComponent);
                        symbolContainer.addChildComponent(vbAnimationHolder, this.symbolName + "_VB");
                        vbAnimationComponent.gotoAndPlay(showInOffScreen, "intro");
                    }
                }
            }
        };
        icyWildsWinLines.ScatterSymbols.prototype.showRegular = function(scatterWins, rgPresentation) {
            icyWildsWinLines.ExternalService.testableLogger.info("scatterWins", {
                scatterWins: scatterWins
            });
            var originalTotalVisibleSymbols = 0;
            if (scatterWins != null) {
                var wins = scatterWins.length;
                var _g = 0;
                while (_g < wins) {
                    var i = _g++;
                    var columns = scatterWins[i].winPath.reelsInfo.length;
                    var _g1 = 0;
                    while (_g1 < columns) {
                        var col = _g1++;
                        var _g3 = 0;
                        var _g2 = this.cellsNum;
                        while (_g3 < _g2) {
                            var row = _g3++;
                            var winId = scatterWins[i].winPath.reelsInfo[col][row + this.symbolOffset];
                            if (winId == 1) {
                                var id = this.symbolName + "_CONTAINER" + "_" + row + "_" + col;
                                if (this.container.getComponentById(id) == null) this.totalVisibleSymbols++;
                            }
                        }
                        originalTotalVisibleSymbols = this.totalVisibleSymbols;
                    }
                }
                var _g4 = 0;
                while (_g4 < wins) {
                    var i1 = _g4++;
                    var columns1 = scatterWins[i1].winPath.reelsInfo.length;
                    var _g11 = 0;
                    while (_g11 < columns1) {
                        var col1 = _g11++;
                        var rows = scatterWins[i1].winPath.reelsInfo[col1].length;
                        var _g31 = 0;
                        var _g21 = this.cellsNum;
                        while (_g31 < _g21) {
                            var row1 = _g31++;
                            var winId1 = scatterWins[i1].winPath.reelsInfo[col1][row1 + this.symbolOffset];
                            if (winId1 == 1) {
                                var id1 = this.symbolName + "_CONTAINER" + "_" + row1 + "_" + col1;
                                if (this.container.getComponentById(id1) == null) {
                                    var vbAsset = this.symbolsAssets.get(this.symbolName + "_VB");
                                    var id2 = this.symbolName + "_" + col1 + "_" + row1;
                                    var vbAnimView = icyWildsWinLines.ExternalService.viewBuilderFactory.createView(vbAsset);
                                    var symbolContainer = this.container.createContainerFromStoredConfig(this.symbolName + "_CONTAINER");
                                    this.container.addChildComponent(symbolContainer, this.symbolName + "_CONTAINER" + "_" + row1 + "_" + col1);
                                    symbolContainer.setX(this.xOffset + (this.symbolWidth + this.horisontalGap) * col1);
                                    symbolContainer.setY(this.yOffset + (this.symbolHeight + this.verticalGap) * row1);
                                    symbolContainer.show();
                                    var vbAnimationHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
                                    var vbAnimationComponent;
                                    vbAnimationComponent = _hcmn_.js_Boot.__cast(vbAnimationHolder.getComponentById("ANIMATION_CONTENT"), viewBuilderApi.IVBAnimationComponent);
                                    symbolContainer.addChildComponent(vbAnimationHolder, this.symbolName + "VB");
                                    if (rgPresentation.isReg) {
                                        if (rgPresentation.isHighWin) vbAnimationComponent.gotoAndPlay(true, "loop", $bind(this, this.played));
                                    } else vbAnimationComponent.gotoAndPlay(true, "loop", $bind(this, this.played));
                                } else {}
                            }
                        }
                    }
                }
            }
            if (originalTotalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("ScatterSymbols");
        };
        icyWildsWinLines.ScatterSymbols.prototype.handleAnimationComplete = function(evt) {};
        icyWildsWinLines.ScatterSymbols.prototype.played = function() {
            this.totalVisibleSymbols--;
            if (this.totalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("ScatterSymbols");
        };
        icyWildsWinLines.ScatterSymbols.prototype.hide = function() {
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.container.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                this.container.disposeChildComponent(key);
            }
            this.totalVisibleSymbols = 0;
        };
        icyWildsWinLines.ScatterSymbols.prototype.__class__ = icyWildsWinLines.ScatterSymbols;
        icyWildsWinLines.TopSymbols = function(container, baseEvents) {
            this.renderOffscreen = false;
            this.isMobile = false;
            this.symbolName = "PRINCESS";
            this.symbolsList = (function($this) {
                var $r;
                var _g = new _hcmn_.haxe_ds_IntMap();
                _g.h[1] = "PRINCESS";
                _g.h[2] = "PRINCESS";
                _g.h[3] = "PRINCESS";
                _g.h[4] = "PRINCESS";
                $r = _g;
                return $r;
            }(this));
            this.totalVisibleSymbols = 0;
            this.symbolOffset = 1;
            this.cellVerticalSpacing = 95;
            this.cellHorizontalSpacing = -51;
            this.cellHeight = 205;
            this.cellWidth = 288;
            this.reelsNum = 5;
            this.cellsNum = 4;
            this.container = container;
            this.baseEvents = baseEvents;
            if (this.renderOffscreen) {
                this.maskedContainer = _hcmn_.js_Boot.__cast(container.getComponentById("maskedContainer"), viewBuilderApi.IViewBuilderContainer);
                var udata = this.maskedContainer.getDisplayObject().getUserData();
                this.offscreenStage = icyWildsWinLines.ExternalService.displayProvider.getFactory().createOffscreenStage(_hcmn_.Std.parseInt(udata.viewBuilderW), _hcmn_.Std.parseInt(udata.viewBuilderH));
                this.OSTimingMode = this.offscreenStage.getStage().getTimingMode();
                container.disposeChildComponent("maskedContainer");
                container.getDisplayObject().addChildAt(icyWildsWinLines.ExternalService.displayProvider.getFactory().createBitmap(this.offscreenStage), 0);
                this.activeVBAnimations = [];
            } else this.maskedContainer = _hcmn_.js_Boot.__cast(container.getComponentById("maskedContainer"), viewBuilderApi.IViewBuilderContainer);
            this.vba = icyWildsWinLines.ExternalService.loadedAssets.get("PRINCESS_VB");
            container.show();
            this.isMobile = window.document.location.href.indexOf("skin=mobile") != -1;
        };
        icyWildsWinLines.TopSymbols = ck_implements(icyWildsWinLines.TopSymbols, icyWildsWinLines.ITopSymbols);
        icyWildsWinLines.TopSymbols.__interfaces__ = [icyWildsWinLines.ITopSymbols];
        icyWildsWinLines.TopSymbols.__name__ = ["icyWildsWinLines", "TopSymbols"];
        icyWildsWinLines.TopSymbols.prototype.container = null;
        icyWildsWinLines.TopSymbols.prototype.baseEvents = null;
        icyWildsWinLines.TopSymbols.prototype.cellsNum = null;
        icyWildsWinLines.TopSymbols.prototype.reelsNum = null;
        icyWildsWinLines.TopSymbols.prototype.cellWidth = null;
        icyWildsWinLines.TopSymbols.prototype.cellHeight = null;
        icyWildsWinLines.TopSymbols.prototype.cellHorizontalSpacing = null;
        icyWildsWinLines.TopSymbols.prototype.cellVerticalSpacing = null;
        icyWildsWinLines.TopSymbols.prototype.symbolOffset = null;
        icyWildsWinLines.TopSymbols.prototype.totalVisibleSymbols = null;
        icyWildsWinLines.TopSymbols.prototype.symbolsList = null;
        icyWildsWinLines.TopSymbols.prototype.symbolName = null;
        icyWildsWinLines.TopSymbols.prototype.bonusWins = null;
        icyWildsWinLines.TopSymbols.prototype.lineWins = null;
        icyWildsWinLines.TopSymbols.prototype.vba = null;
        icyWildsWinLines.TopSymbols.prototype.vbAnimView = null;
        icyWildsWinLines.TopSymbols.prototype.maskedContainer = null;
        icyWildsWinLines.TopSymbols.prototype.offscreenStage = null;
        icyWildsWinLines.TopSymbols.prototype.OSTimingMode = null;
        icyWildsWinLines.TopSymbols.prototype.isMobile = null;
        icyWildsWinLines.TopSymbols.prototype.renderOffscreen = null;
        icyWildsWinLines.TopSymbols.prototype.activeVBAnimations = null;
        icyWildsWinLines.TopSymbols.prototype.show = function(winsymbols, outcome, rgPresentation) {
            this.container.show();
            if (outcome != null) {
                if (outcome.reelStop != null) {
                    if (outcome.reelStop.reels != null) this.handleOutcome(winsymbols, outcome.reelStop.reels, rgPresentation);
                }
            }
            icyWildsWinLines.ExternalService.testableLogger.info("scatterWins:topSymbols: ", {
                topSymbols: winsymbols
            });
        };
        icyWildsWinLines.TopSymbols.prototype.handleOutcome = function(winsymbols, reelstop, rgPresentation) {
            var originalTotalVisibleSymbols = 0;
            var showInOffScreen = false;
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var col = _g1++;
                var _g3 = 0;
                var _g2 = this.cellsNum;
                while (_g3 < _g2) {
                    var row = _g3++;
                    var symbolNum = reelstop[col][row + this.symbolOffset];
                    var symbolVisible = winsymbols[col][row];
                    var symbolNum1 = reelstop[col][row + this.symbolOffset];
                    var symbolVisible1 = winsymbols[col][row];
                    if (symbolVisible1 && (function($this) {
                            var $r;
                            var key = symbolNum1;
                            $r = $this.symbolsList.h.hasOwnProperty(key);
                            return $r;
                        }(this))) {
                        this.totalVisibleSymbols++;
                        break;
                    }
                }
                originalTotalVisibleSymbols = this.totalVisibleSymbols;
                if (originalTotalVisibleSymbols > 1) showInOffScreen = true;
            }
            var _g11 = 0;
            var _g4 = this.reelsNum;
            while (_g11 < _g4) {
                var col1 = _g11++;
                var symbolPosition = 1;
                var _g31 = 0;
                var _g21 = this.cellsNum;
                while (_g31 < _g21) {
                    var row1 = _g31++;
                    var symbolNum2 = reelstop[col1][row1 + this.symbolOffset];
                    var symbolVisible2 = winsymbols[col1][row1];
                    if (symbolVisible2 && (function($this) {
                            var $r;
                            var key1 = symbolNum2;
                            $r = $this.symbolsList.h.hasOwnProperty(key1);
                            return $r;
                        }(this))) {
                        if (symbolNum2 == "1") symbolPosition -= row1;
                        else symbolPosition += _hcmn_.Std.parseInt(symbolNum2) - row1 - 1;
                        break;
                    }
                }
                var _g32 = 0;
                var _g22 = this.cellsNum;
                while (_g32 < _g22) {
                    var row2 = _g32++;
                    var symbolNum3 = reelstop[col1][row2 + this.symbolOffset];
                    var symbolVisible3 = winsymbols[col1][row2];
                    if (symbolVisible3) {
                        if ((function($this) {
                                var $r;
                                var key2 = symbolNum3;
                                $r = $this.symbolsList.h.hasOwnProperty(key2);
                                return $r;
                            }(this))) {
                            if (this.vbAnimView == null) this.vbAnimView = icyWildsWinLines.ExternalService.viewBuilderFactory.createView(this.vba);
                            var vbAnimationHolder = this.vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
                            var vbAnimationComponent;
                            vbAnimationComponent = _hcmn_.js_Boot.__cast(vbAnimationHolder.getComponentById("ANIMATION_CONTENT"), viewBuilderApi.IVBAnimationComponent);
                            vbAnimationHolder.getDisplayObject().setX(this.cellHorizontalSpacing + this.cellWidth * col1);
                            vbAnimationHolder.getDisplayObject().setY(this.cellVerticalSpacing - this.cellHeight * symbolPosition);
                            if (!this.renderOffscreen) this.maskedContainer.addChildComponent(vbAnimationHolder, this.symbolName + "VB" + "_" + col1);
                            else {
                                this.offscreenStage.getStage().addChildAt(vbAnimationHolder.getDisplayObject(), 0);
                                this.activeVBAnimations.push(vbAnimationComponent);
                            }
                            vbAnimationComponent.playParticles = !this.isMobile;
                            if (rgPresentation.isReg) {
                                if (rgPresentation.isHighWin) vbAnimationComponent.play(showInOffScreen, $bind(this, this.played));
                            } else vbAnimationComponent.play(showInOffScreen, $bind(this, this.played));
                            vbAnimationHolder.getDisplayObject().getParent().setChildIndex(vbAnimationHolder.getDisplayObject(), vbAnimationHolder.getDisplayObject().getParent().getNumChildren() - 1);
                            break;
                        }
                    }
                }
            }
            if (originalTotalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("TopSymbols");
            else {
                this.container.show();
                if (this.renderOffscreen) this.offscreenStage.getStage().setTimingMode(this.OSTimingMode);
            }
        };
        icyWildsWinLines.TopSymbols.prototype.hide = function() {
            if (this.renderOffscreen) {
                this.offscreenStage.getStage().removeAllChildren();
                this.offscreenStage.getStage().setTimingMode(displayEngineApi.TimingMode.ONCE);
                haxe.Log.trace("::im TS hide()", {
                    fileName: "TopSymbols.hx",
                    lineNumber: 202,
                    className: "icywilds.components.winlines.component.imp.components.TopSymbols",
                    methodName: "hide",
                    customParams: [this.activeVBAnimations.length]
                });
                while (this.activeVBAnimations.length > 0) {
                    var vbAnim = this.activeVBAnimations.pop();
                    vbAnim.dispose();
                    vbAnim = null;
                }
                haxe.Log.trace("::im TS hide() after", {
                    fileName: "TopSymbols.hx",
                    lineNumber: 210,
                    className: "icywilds.components.winlines.component.imp.components.TopSymbols",
                    methodName: "hide",
                    customParams: [this.activeVBAnimations.length]
                });
            } else {
                var $it0 = (function($this) {
                    var $r;
                    var this1 = $this.maskedContainer.getChildComponents();
                    $r = this1.keys();
                    return $r;
                }(this));
                while ($it0.hasNext()) {
                    var key = $it0.next();
                    this.maskedContainer.disposeChildComponent(key);
                }
            }
            this.container.hide();
            this.totalVisibleSymbols = 0;
        };
        icyWildsWinLines.TopSymbols.prototype.played = function() {
            this.totalVisibleSymbols--;
            if (this.totalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("TopSymbols");
        };
        icyWildsWinLines.TopSymbols.prototype.__class__ = icyWildsWinLines.TopSymbols;
        icyWildsWinLines.WinFrames = function(container, baseEvents) {
            this.loop = true;
            this.symbolsList = (function($this) {
                var $r;
                var _g = new _hcmn_.haxe_ds_StringMap();
                if (_hcmn_.__map_reserved["1"] != null) _g.setReserved("1", "PRINCESS");
                else _g.h["1"] = "PRINCESS";
                if (_hcmn_.__map_reserved["2"] != null) _g.setReserved("2", "PRINCESS");
                else _g.h["2"] = "PRINCESS";
                if (_hcmn_.__map_reserved["3"] != null) _g.setReserved("3", "PRINCESS");
                else _g.h["3"] = "PRINCESS";
                if (_hcmn_.__map_reserved["4"] != null) _g.setReserved("4", "PRINCESS");
                else _g.h["4"] = "PRINCESS";
                $r = _g;
                return $r;
            }(this));
            this.reelOffset = 1;
            this.totalWins = 0;
            this.currentLine = 0;
            this.reelsNum = 5;
            this.cellsNum = 4;
            this.width = 278;
            this.height = 205;
            this.verticalGap = 0;
            this.horisontalGap = 10;
            this.baseEvents = baseEvents;
            this.container = container;
        };
        icyWildsWinLines.WinFrames = ck_implements(icyWildsWinLines.WinFrames, icyWildsWinLines.IWinFrames);
        icyWildsWinLines.WinFrames.__interfaces__ = [icyWildsWinLines.IWinFrames];
        icyWildsWinLines.WinFrames.__name__ = ["icyWildsWinLines", "WinFrames"];
        icyWildsWinLines.WinFrames.prototype.container = null;
        icyWildsWinLines.WinFrames.prototype.horisontalGap = null;
        icyWildsWinLines.WinFrames.prototype.verticalGap = null;
        icyWildsWinLines.WinFrames.prototype.height = null;
        icyWildsWinLines.WinFrames.prototype.width = null;
        icyWildsWinLines.WinFrames.prototype.cellsNum = null;
        icyWildsWinLines.WinFrames.prototype.reelsNum = null;
        icyWildsWinLines.WinFrames.prototype.currentLine = null;
        icyWildsWinLines.WinFrames.prototype.totalWins = null;
        icyWildsWinLines.WinFrames.prototype.outcome = null;
        icyWildsWinLines.WinFrames.prototype.timer = null;
        icyWildsWinLines.WinFrames.prototype.allLineWins = null;
        icyWildsWinLines.WinFrames.prototype.reelOffset = null;
        icyWildsWinLines.WinFrames.prototype.baseEvents = null;
        icyWildsWinLines.WinFrames.prototype.symbolsList = null;
        icyWildsWinLines.WinFrames.prototype.loop = null;
        icyWildsWinLines.WinFrames.prototype.setOutcome = function(outcome, lineTime, loop, rgPresentation) {
            this.loop = loop;
            this.outcome = outcome;
            this.container.show();
            this.allLineWins = [];
            if (outcome != null) {
                if (outcome.lineWins != null) {
                    if (outcome.lineWins.length > 0) {
                        var _g1 = 0;
                        var _g = outcome.lineWins.length;
                        while (_g1 < _g) {
                            var i = _g1++;
                            this.allLineWins.push(outcome.lineWins[i]);
                        }
                    }
                }
                if (outcome.bonusWins != null) {
                    if (outcome.bonusWins.length > 0) {
                        var _g11 = 0;
                        var _g2 = outcome.bonusWins.length;
                        while (_g11 < _g2) {
                            var i1 = _g11++;
                            if (outcome.bonusWins[i1].type == "Princess") this.allLineWins.push(outcome.bonusWins[i1]);
                        }
                    }
                }
                if (outcome.scatterWins != null) {
                    if (outcome.scatterWins.length > 0) {
                        var _g12 = 0;
                        var _g3 = outcome.scatterWins.length;
                        while (_g12 < _g3) {
                            var i2 = _g12++;
                            var hasWin = false;
                            var rls = outcome.scatterWins[i2].winPath.reelsInfo.length;
                            var _g21 = 0;
                            while (_g21 < rls) {
                                var j = _g21++;
                                var rws = outcome.scatterWins[i2].winPath.reelsInfo[j].length;
                                var _g31 = 0;
                                while (_g31 < rws) {
                                    var k = _g31++;
                                    if (outcome.scatterWins[i2].winPath.reelsInfo[j][k] == 1) hasWin = true;
                                    else {}
                                }
                            }
                            if (hasWin) this.allLineWins.push(outcome.scatterWins[i2]);
                        }
                    }
                }
            }
            this.currentLine = 0;
            this.totalWins = this.allLineWins.length;
            this.sortData();
            this.timer = new _hcmn_.haxe_Timer(lineTime);
            if (this.totalWins == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED).dispatch(this.currentLine);
            else this.enterCycle();
        };
        icyWildsWinLines.WinFrames.prototype.sortData = function() {
            this.allLineWins.sort(function(a, b) {
                if (a.lineId < b.lineId) return -1;
                if (a.lineId > b.lineId) return 1;
                return 0;
            });
            var _g1 = 0;
            var _g = this.allLineWins.length - 1;
            while (_g1 < _g) {
                var i = _g1++;
                if (this.allLineWins[i].lineId == this.allLineWins[i + 1].lineId) {
                    if (this.allLineWins[i].type == "Princess") {
                        var temp = this.allLineWins[i];
                        this.allLineWins[i] = this.allLineWins[i + 1];
                        this.allLineWins[i + 1] = temp;
                    }
                }
            }
            var _g11 = 0;
            var _g2 = this.allLineWins.length;
            while (_g11 < _g2) {
                var i1 = _g11++;
                if (this.allLineWins[i1].type == "Scatter") {
                    this.allLineWins.push(this.allLineWins[i1]);
                    _hcmn_.HxOverrides.remove(this.allLineWins, this.allLineWins[i1]);
                }
            }
        };
        icyWildsWinLines.WinFrames.prototype.enterCycle = function() {
            var _g = this;
            this.show();
            if (this.timer != null) this.timer.run = function() {
                _g.show();
                if (!_g.loop) {
                    if (_g.currentLine > _g.totalWins) {
                        _g.currentLine = 0;
                        _g.timer.stop();
                        _g.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED).dispatch(_g.currentLine);
                    }
                } else if (_g.currentLine >= _g.totalWins) _g.currentLine = 0;
            };
        };
        icyWildsWinLines.WinFrames.prototype.show = function() {
            if (this.allLineWins[this.currentLine] != null) this.handleLineWin();
            this.currentLine++;
        };
        icyWildsWinLines.WinFrames.prototype.handleLineWin = function() {
            var winLine = this.allLineWins[this.currentLine].winPath.reelsInfo;
            var frameVisible = 0;
            var isTopSymbol = false;
            var isScatterSymbol = false;
            var isDisabled = frameVisible == 2;
            var isEnabled = frameVisible == 1;
            var contId = "";
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var i = _g1++;
                var _g3 = 0;
                var _g2 = this.cellsNum;
                while (_g3 < _g2) {
                    var j = _g3++;
                    frameVisible = winLine[i][j + this.reelOffset];
                    isDisabled = frameVisible == 2;
                    isEnabled = frameVisible == 1;
                    isTopSymbol = false;
                    isScatterSymbol = false;
                    contId = "";
                    if (this.symbolsList.exists(this.outcome.reelStop.reels[i][j + this.reelOffset])) isTopSymbol = true;
                    if (this.outcome.reelStop.reels[i][j + this.reelOffset] != null) {
                        if (this.outcome.reelStop.reels[i][j + this.reelOffset] == "27") isScatterSymbol = true;
                    }
                    if (isTopSymbol) {
                        if (j == 0) contId = "FRAME_CONTAINER_TOP";
                        else if (j == this.cellsNum - 1) contId = "FRAME_CONTAINER_BOTTOM";
                        else contId = "FRAME_CONTAINER_CENTER";
                    } else if (isScatterSymbol) contId = "FRAME_CONTAINER_SCATTER";
                    else contId = "FRAME_CONTAINER_REGULAR";
                    this.showFrame(i, j, frameVisible, contId);
                }
            }
            _hcmn_.haxe_Timer.delay(function() {
                icyWildsWinLines.ExternalService.testableLogger.info("Win Frames", {
                    reelsInfo: winLine
                });
            }, 100);
            this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN).dispatch(this.allLineWins[this.currentLine]);
        };
        icyWildsWinLines.WinFrames.prototype.showFrame = function(i, j, frameVisible, contId) {
            var id;
            id = contId + (i == null ? "null" : "" + i) + (j == null ? "null" : "" + j);
            var symbolExists = false;
            if (this.container.getComponentById(id) != null) symbolExists = true;
            var visible = frameVisible > 0;
            var isDisabled = frameVisible == 2;
            if (visible) {
                if (symbolExists) {
                    var symbol = this.container.getComponentById(id);
                    var disabledSymbol = symbol.getComponentById("DISABLED");
                    disabledSymbol.hide();
                    var enabledSymbol = symbol.getComponentById("ENABLED");
                    enabledSymbol.hide();
                    if (isDisabled) {
                        enabledSymbol.hide();
                        disabledSymbol.show();
                    } else {
                        disabledSymbol.hide();
                        enabledSymbol.show();
                    }
                    symbol.show();
                } else if (!symbolExists) {
                    var symbol1 = this.container.createContainerFromStoredConfig(contId);
                    symbol1.show();
                    this.container.addChildComponent(symbol1, id);
                    var x = (this.width + this.horisontalGap) * i;
                    var y = (this.height + this.verticalGap) * j;
                    symbol1.setX(x);
                    symbol1.setY(y);
                    var disabledSymbol1 = symbol1.getComponentById("DISABLED");
                    disabledSymbol1.hide();
                    var enabledSymbol1 = symbol1.getComponentById("ENABLED");
                    enabledSymbol1.hide();
                    if (isDisabled) {
                        enabledSymbol1.hide();
                        disabledSymbol1.show();
                    } else {
                        enabledSymbol1.show();
                        disabledSymbol1.hide();
                    }
                }
            } else if (symbolExists) {
                var symbol2 = this.container.getComponentById(id);
                symbol2.hide();
            }
        };
        icyWildsWinLines.WinFrames.prototype.hide = function() {
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.container.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                this.container.disposeChildComponent(key);
            }
            this.container.getDisplayObject().removeChildren();
            this.allLineWins = null;
            if (this.timer != null) {
                this.timer.stop();
                this.timer.run = null;
                this.timer = null;
            }
            this.container.hide();
        };
        icyWildsWinLines.WinFrames.prototype.__class__ = icyWildsWinLines.WinFrames;
        icyWildsWinLines.WinSymbols = function(container, baseEvents) {
            this.isMobile = false;
            this.originalSymbols = new _hcmn_.haxe_ds_StringMap();
            this.symbolsList = (function($this) {
                var $r;
                var _g = new _hcmn_.haxe_ds_IntMap();
                _g.h[5] = "HS_CROWN";
                _g.h[6] = "HS_CROWN";
                _g.h[7] = "HS_RING";
                _g.h[8] = "HS_RING";
                _g.h[9] = "HS_HEART";
                _g.h[10] = "HS_HEART";
                _g.h[11] = "HS_LEOPARD";
                _g.h[12] = "HS_LEOPARD";
                _g.h[13] = "LS_OWL";
                _g.h[14] = "LS_OWL";
                _g.h[15] = "HS_HERMALINE";
                _g.h[16] = "HS_HERMALINE";
                _g.h[17] = "LS_A_ZOOM";
                _g.h[18] = "LS_A_ZOOM";
                _g.h[19] = "LS_K_ZOOM";
                _g.h[20] = "LS_K_ZOOM";
                _g.h[21] = "LS_Q_ZOOM";
                _g.h[22] = "LS_Q_ZOOM";
                _g.h[23] = "LS_J_ZOOM";
                _g.h[24] = "LS_J_ZOOM";
                _g.h[25] = "LS_10";
                _g.h[26] = "LS_10";
                $r = _g;
                return $r;
            }(this));
            this.totalVisibleSymbols = 0;
            this.symbolOffset = 1;
            this.reelsNum = 5;
            this.cellsNum = 4;
            this.verticalGap = 0;
            this.horisontalGap = 10;
            this.symbolHeight = 205;
            this.symbolWidth = 278;
            this.container = container;
            this.baseEvents = baseEvents;
            this.maskedContainer = _hcmn_.js_Boot.__cast(container.getComponentById("maskedContainer"), viewBuilderApi.IViewBuilderContainer);
            container.disposeChildComponent("maskedContainer");
            container.hide();
            this.isMobile = window.document.location.href.indexOf("skin=mobile") != -1;
        };
        icyWildsWinLines.WinSymbols = ck_implements(icyWildsWinLines.WinSymbols, icyWildsWinLines.IWinSymbols);
        icyWildsWinLines.WinSymbols.__interfaces__ = [icyWildsWinLines.IWinSymbols];
        icyWildsWinLines.WinSymbols.__name__ = ["icyWildsWinLines", "WinSymbols"];
        icyWildsWinLines.WinSymbols.prototype.container = null;
        icyWildsWinLines.WinSymbols.prototype.baseEvents = null;
        icyWildsWinLines.WinSymbols.prototype.symbolWidth = null;
        icyWildsWinLines.WinSymbols.prototype.symbolHeight = null;
        icyWildsWinLines.WinSymbols.prototype.horisontalGap = null;
        icyWildsWinLines.WinSymbols.prototype.verticalGap = null;
        icyWildsWinLines.WinSymbols.prototype.cellsNum = null;
        icyWildsWinLines.WinSymbols.prototype.reelsNum = null;
        icyWildsWinLines.WinSymbols.prototype.symbolOffset = null;
        icyWildsWinLines.WinSymbols.prototype.totalVisibleSymbols = null;
        icyWildsWinLines.WinSymbols.prototype.symbolsList = null;
        icyWildsWinLines.WinSymbols.prototype.originalSymbols = null;
        icyWildsWinLines.WinSymbols.prototype.config = null;
        icyWildsWinLines.WinSymbols.prototype.maskedContainer = null;
        icyWildsWinLines.WinSymbols.prototype.isMobile = null;
        icyWildsWinLines.WinSymbols.prototype.show = function(winsymbols, outcome, rgPresentation) {
            haxe.Log.trace("[LN]: winLines.winSymbols.outcome " + _hcmn_.Std.string(outcome), {
                fileName: "WinSymbols.hx",
                lineNumber: 88,
                className: "icywilds.components.winlines.component.imp.components.WinSymbols",
                methodName: "show"
            });
            var originalTotalVisibleSymbols = 0;
            var animatedCountPerSymbols = new _hcmn_.haxe_ds_IntMap();
            icyWildsWinLines.ExternalService.testableLogger.info("winsymbols", {
                winsymbols: winsymbols
            });
            if (outcome != null) {
                if (outcome.reelStop != null) icyWildsWinLines.ExternalService.testableLogger.info("reelPicture", {
                    reelstop: outcome.reelStop.reels
                });
            }
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var col = _g1++;
                var _g3 = 0;
                var _g2 = this.cellsNum;
                while (_g3 < _g2) {
                    var row = _g3++;
                    var symbolNum = outcome.reelStop.reels[col][row + this.symbolOffset];
                    var symbolVisible = winsymbols[col][row];
                    if (symbolVisible && (function($this) {
                            var $r;
                            var key = symbolNum;
                            $r = $this.symbolsList.h.hasOwnProperty(key);
                            return $r;
                        }(this)) && !(function($this) {
                            var $r;
                            var key1; {
                                var key2 = symbolNum;
                                key1 = $this.symbolsList.h[key2];
                            }
                            $r = $this.originalSymbols.exists(key1);
                            return $r;
                        }(this))) {
                        if (!(function($this) {
                                var $r;
                                var key3 = symbolNum;
                                $r = animatedCountPerSymbols.h.hasOwnProperty(key3);
                                return $r;
                            }(this))) {
                            var key4 = symbolNum;
                            animatedCountPerSymbols.h[key4] = 0;
                        }
                        var key5 = symbolNum;
                        var value;
                        value = (function($this) {
                            var $r;
                            var key6 = symbolNum;
                            $r = animatedCountPerSymbols.h[key6];
                            return $r;
                        }(this)) + 1;
                        animatedCountPerSymbols.h[key5] = value;
                        this.totalVisibleSymbols++;
                    }
                }
            }
            haxe.Log.trace("::im show win symbols", {
                fileName: "WinSymbols.hx",
                lineNumber: 117,
                className: "icywilds.components.winlines.component.imp.components.WinSymbols",
                methodName: "show",
                customParams: [animatedCountPerSymbols]
            });
            originalTotalVisibleSymbols = this.totalVisibleSymbols;
            var _g11 = 0;
            var _g4 = this.reelsNum;
            while (_g11 < _g4) {
                var col1 = _g11++;
                var _g31 = 0;
                var _g21 = this.cellsNum;
                while (_g31 < _g21) {
                    var row1 = _g31++;
                    var symbolNum1 = outcome.reelStop.reels[col1][row1 + this.symbolOffset];
                    var symbolVisible1 = winsymbols[col1][row1];
                    if (symbolVisible1) {
                        if ((function($this) {
                                var $r;
                                var key7 = symbolNum1;
                                $r = $this.symbolsList.h.hasOwnProperty(key7);
                                return $r;
                            }(this))) {
                            if ((function($this) {
                                    var $r;
                                    var key8; {
                                        var key9 = symbolNum1;
                                        key8 = $this.symbolsList.h[key9];
                                    }
                                    $r = $this.originalSymbols.exists(key8);
                                    return $r;
                                }(this))) {
                                var newSymbol = ((function($this) {
                                    var $r;
                                    var key10; {
                                        var key11 = symbolNum1;
                                        key10 = $this.symbolsList.h[key11];
                                    }
                                    $r = $this.originalSymbols.get(key10);
                                    return $r;
                                }(this))).toBitmap();
                                if (newSymbol != null) {
                                    this.container.getDisplayObject().addChild(newSymbol);
                                    newSymbol.setX((this.symbolWidth + this.horisontalGap) * col1);
                                    newSymbol.setY((this.symbolHeight + this.verticalGap) * row1);
                                }
                            } else {
                                var symbolName;
                                var key12 = symbolNum1;
                                symbolName = this.symbolsList.h[key12];
                                var vbAsset = icyWildsWinLines.ExternalService.loadedAssets.get(symbolName + "_VB");
                                if (vbAsset != null) {
                                    var vbAnimView = icyWildsWinLines.ExternalService.viewBuilderFactory.createView(vbAsset);
                                    var symbolContainer = this.container.createContainerFromStoredConfig(symbolName + "_CONTAINER");
                                    this.container.addChildComponent(symbolContainer, symbolName + "_CONTAINER" + "_" + row1 + "_" + col1);
                                    symbolContainer.setX((this.symbolWidth + this.horisontalGap) * col1);
                                    symbolContainer.setY((this.symbolHeight + this.verticalGap) * row1);
                                    symbolContainer.show();
                                    var vbAniamtionHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
                                    var vbAnimationComponent;
                                    vbAnimationComponent = _hcmn_.js_Boot.__cast(vbAniamtionHolder.getComponentById("ANIMATION_CONTENT"), viewBuilderApi.IVBAnimationComponent);
                                    symbolContainer.addChildComponent(vbAniamtionHolder, symbolName + "VB");
                                    vbAnimationComponent.playParticles = !this.isMobile;
                                    var offScreen;
                                    offScreen = (function($this) {
                                        var $r;
                                        var key13 = symbolNum1;
                                        $r = animatedCountPerSymbols.h.hasOwnProperty(key13);
                                        return $r;
                                    }(this)) && (function($this) {
                                        var $r;
                                        var key14 = symbolNum1;
                                        $r = animatedCountPerSymbols.h[key14];
                                        return $r;
                                    }(this)) > 1;
                                    offScreen = true;
                                    if (rgPresentation.isReg) {
                                        if (rgPresentation.isHighWin) vbAnimationComponent.play(offScreen, $bind(this, this.played));
                                    } else vbAnimationComponent.play(offScreen, $bind(this, this.played));
                                }
                            }
                        }
                    }
                }
            }
            if (originalTotalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("WinSymbols");
            this.container.show();
        };
        icyWildsWinLines.WinSymbols.prototype.hide = function() {
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.container.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                this.container.disposeChildComponent(key);
            }
            var $it1 = this.originalSymbols.keys();
            while ($it1.hasNext()) {
                var key1 = $it1.next();
                this.originalSymbols.get(key1).dispose();
                this.originalSymbols.remove(key1);
            }
            this.totalVisibleSymbols = 0;
            this.originalSymbols = new _hcmn_.haxe_ds_StringMap();
        };
        icyWildsWinLines.WinSymbols.prototype.played = function() {
            this.totalVisibleSymbols--;
            if (this.totalVisibleSymbols == 0) this.baseEvents.getEvent(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED).dispatch("WinSymbols");
        };
        icyWildsWinLines.WinSymbols.prototype.__class__ = icyWildsWinLines.WinSymbols;
        icyWildsWinLines.BaseEventsEnum = {
            __ename__: ["icyWildsWinLines", "BaseEventsEnum"],
            __constructs__: ["WIN_FRAMES_CYCLE_ENDED", "CURRENT_WIN_LINE_SHOWN", "CALLBACK_RECIVED"]
        };
        icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED = ["CALLBACK_RECIVED", 2];
        icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED.toString = $estr;
        icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED.__enum__ = icyWildsWinLines.BaseEventsEnum;
        icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN = ["CURRENT_WIN_LINE_SHOWN", 1];
        icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.toString = $estr;
        icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.__enum__ = icyWildsWinLines.BaseEventsEnum;
        icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED = ["WIN_FRAMES_CYCLE_ENDED", 0];
        icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.toString = $estr;
        icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.__enum__ = icyWildsWinLines.BaseEventsEnum;
        icyWildsWinLines.ComponentsEnum = {
            __ename__: ["icyWildsWinLines", "ComponentsEnum"],
            __constructs__: ["WIN_FRAMES", "SKATTER_SYMBOLS", "WIN_SYMBOLS", "TOP_SYMBOLS"]
        };
        icyWildsWinLines.ComponentsEnum.TOP_SYMBOLS = ["TOP_SYMBOLS", 3];
        icyWildsWinLines.ComponentsEnum.TOP_SYMBOLS.toString = $estr;
        icyWildsWinLines.ComponentsEnum.TOP_SYMBOLS.__enum__ = icyWildsWinLines.ComponentsEnum;
        icyWildsWinLines.ComponentsEnum.WIN_FRAMES = ["WIN_FRAMES", 0];
        icyWildsWinLines.ComponentsEnum.WIN_FRAMES.toString = $estr;
        icyWildsWinLines.ComponentsEnum.WIN_FRAMES.__enum__ = icyWildsWinLines.ComponentsEnum;
        icyWildsWinLines.ComponentsEnum.SKATTER_SYMBOLS = ["SKATTER_SYMBOLS", 1];
        icyWildsWinLines.ComponentsEnum.SKATTER_SYMBOLS.toString = $estr;
        icyWildsWinLines.ComponentsEnum.SKATTER_SYMBOLS.__enum__ = icyWildsWinLines.ComponentsEnum;
        icyWildsWinLines.ComponentsEnum.WIN_SYMBOLS = ["WIN_SYMBOLS", 2];
        icyWildsWinLines.ComponentsEnum.WIN_SYMBOLS.toString = $estr;
        icyWildsWinLines.ComponentsEnum.WIN_SYMBOLS.__enum__ = icyWildsWinLines.ComponentsEnum;
        icyWildsWinLines.BaseEvents = function() {
            this.events = new haxe.ds.EnumValueMap();
            this.registerEvents();
        };
        icyWildsWinLines.BaseEvents.__name__ = ["icyWildsWinLines", "BaseEvents"];
        icyWildsWinLines.BaseEvents.prototype.events = null;
        icyWildsWinLines.BaseEvents.prototype.registerEvents = function() {
            var value = new _hcmn_.msignal_Signal1();
            this.events.set(icyWildsWinLines.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED, value);
            var value1 = new _hcmn_.msignal_Signal1();
            this.events.set(icyWildsWinLines.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN, value1);
            var value2 = new _hcmn_.msignal_Signal1();
            this.events.set(icyWildsWinLines.BaseEventsEnum.CALLBACK_RECIVED, value2);
        };
        icyWildsWinLines.BaseEvents.prototype.getEvent = function(id) {
            return this.events.get(id);
        };
        icyWildsWinLines.BaseEvents.prototype.__class__ = icyWildsWinLines.BaseEvents;
        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;
        icyWildsWinLines.ExternalService.loadedAssets = new _hcmn_.haxe_ds_StringMap();;
        return {
            exports: icyWildsWinLines,
            activator: icyWildsWinLines.Activator
        };
    });
//# sourceURL=icyWildsWinLines.js