define("tripleRedHotSevensIXFGameController", ["tripleRedHotSevensIXFComponentsGameControllerApi", "tripleRedHotSevensIXFTutorialApi", "commonControls", "componentmodelComponentApi", "translationmanagerApi", "clientkernelLoaderApi", "slotModelApi", "winMeterApi", "displayEngineApi", "tripleRedHotSevensIXFPopupsApi", "winControllerApi", "animationPort", "reelsApi", "commonTools", "gameLayoutApi", "clientkernelEventbusApi", "stateMachineEngine", "infoBarApi", "soundEventTool", "backgroundApi", "clientkernelModulesApi", "paytableApi", "betPanelApi", "clientkernelLoggerApi", "moneyApi"],
    function(tripleRedHotSevensIXFComponentsGameControllerApi, tripleRedHotSevensIXFTutorialApi, commonControls, componentmodelComponentApi, translationmanagerApi, clientkernelLoaderApi, slotModelApi, winMeterApi, displayEngineApi, tripleRedHotSevensIXFPopupsApi, winControllerApi, animationPort, reelsApi, commonTools, gameLayoutApi, clientkernelEventbusApi, stateMachineEngine, infoBarApi, soundEventTool, backgroundApi, clientkernelModulesApi, paytableApi, betPanelApi, clientkernelLoggerApi, moneyApi) {
        "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 tripleRedHotSevensIXFGameController == 'undefined') {
            var tripleRedHotSevensIXFGameController = {};
        };
        tripleRedHotSevensIXFGameController.Activator = function() {};
        tripleRedHotSevensIXFGameController.Activator = ck_implements(tripleRedHotSevensIXFGameController.Activator, clientkernelModulesApi.IModuleActivator);
        tripleRedHotSevensIXFGameController.Activator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        tripleRedHotSevensIXFGameController.Activator.__name__ = ["tripleRedHotSevensIXFGameController", "Activator"];
        tripleRedHotSevensIXFGameController.Activator.prototype.start = function(context) {
            context.getServiceTracker([translationmanagerApi.ITranslationManager, moneyApi.IMoneyFormatter]).then(function(context1) {
                tripleRedHotSevensIXFGameController.ExternalService.initialize(context1);
                context1.registerService(new tripleRedHotSevensIXFGameController.Factory(), tripleRedHotSevensIXFComponentsGameControllerApi.GameControllerDeclaration, null);
            });
        };
        tripleRedHotSevensIXFGameController.Activator.prototype.stop = function(context) {};
        tripleRedHotSevensIXFGameController.Activator.main = function() {};
        tripleRedHotSevensIXFGameController.Activator.prototype.__class__ = tripleRedHotSevensIXFGameController.Activator;
        tripleRedHotSevensIXFGameController.ExternalService = function() {};
        tripleRedHotSevensIXFGameController.ExternalService.__name__ = ["tripleRedHotSevensIXFGameController", "ExternalService"];
        tripleRedHotSevensIXFGameController.ExternalService.bus = null;
        tripleRedHotSevensIXFGameController.ExternalService.assetRegistry = null;
        tripleRedHotSevensIXFGameController.ExternalService.moneyFormatter = null;
        tripleRedHotSevensIXFGameController.ExternalService.translationManager = null;
        tripleRedHotSevensIXFGameController.ExternalService.moneyValueProvider = null;
        tripleRedHotSevensIXFGameController.ExternalService.variableRegistry = null;
        tripleRedHotSevensIXFGameController.ExternalService.logger = null;
        tripleRedHotSevensIXFGameController.ExternalService.busChanel = null;
        tripleRedHotSevensIXFGameController.ExternalService.loggerFactory = null;
        tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService = null;
        tripleRedHotSevensIXFGameController.ExternalService._moduleContext = null;
        tripleRedHotSevensIXFGameController.ExternalService.initialize = function(context) {
            tripleRedHotSevensIXFGameController.ExternalService._moduleContext = context;
            tripleRedHotSevensIXFGameController.ExternalService.bus = context.getAnyService(clientkernelEventbusApi.IEventBus, null);
            tripleRedHotSevensIXFGameController.ExternalService.busChanel = tripleRedHotSevensIXFGameController.ExternalService.bus.getChannel("GFBus");
            tripleRedHotSevensIXFGameController.ExternalService.assetRegistry = context.getAnyService(clientkernelLoaderApi.IAssetRegistry, null);
            tripleRedHotSevensIXFGameController.ExternalService.moneyFormatter = context.getAnyService(moneyApi.IMoneyFormatter, null);
            tripleRedHotSevensIXFGameController.ExternalService.moneyValueProvider = new commonTools.MoneyValueProvider(tripleRedHotSevensIXFGameController.ExternalService.moneyFormatter);
            tripleRedHotSevensIXFGameController.ExternalService.variableRegistry = context.getAnyService(clientkernelLoaderApi.IVariableRegistry, null);
            tripleRedHotSevensIXFGameController.ExternalService.translationManager = context.getAnyService(translationmanagerApi.ITranslationManager, null);
            tripleRedHotSevensIXFGameController.ExternalService.loggerFactory = context.getAnyService(clientkernelLoggerApi.ILoggerFactory, null);
            tripleRedHotSevensIXFGameController.ExternalService.logger = tripleRedHotSevensIXFGameController.ExternalService.loggerFactory.getLogger(context.getModule().getSymbolicName());
            console.log("[pt] GC winControllerPluginService: " + _hcmn_.Std.string(tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService));
        };
        tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin = function() {
            tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService = tripleRedHotSevensIXFGameController.ExternalService._moduleContext.getAnyService(winControllerApi.IWinControllerPluginService);
        };
        tripleRedHotSevensIXFGameController.ExternalService.isDevice = function() {
            return tripleRedHotSevensIXFGameController.ExternalService.checkIsDevice("mobile") || tripleRedHotSevensIXFGameController.ExternalService.checkIsDevice("tablet");
        };
        tripleRedHotSevensIXFGameController.ExternalService.isMini = function() {
            return tripleRedHotSevensIXFGameController.ExternalService.variableRegistry.get("presenttype") == "MIN" || tripleRedHotSevensIXFGameController.ExternalService.variableRegistry.get("assetPack") == "desktopmini" || tripleRedHotSevensIXFGameController.ExternalService.variableRegistry.get("assetPack") == "tabletmini";
        };
        tripleRedHotSevensIXFGameController.ExternalService.checkIsDevice = function(deviceType) {
            var skin = tripleRedHotSevensIXFGameController.ExternalService.variableRegistry.get("skin");
            var assetPack = tripleRedHotSevensIXFGameController.ExternalService.variableRegistry.get("assetPack");
            return skin == deviceType || assetPack == deviceType;
        };
        tripleRedHotSevensIXFGameController.ExternalService.prototype.__class__ = tripleRedHotSevensIXFGameController.ExternalService;
        tripleRedHotSevensIXFGameController.Factory = function() {};
        tripleRedHotSevensIXFGameController.Factory = ck_implements(tripleRedHotSevensIXFGameController.Factory, clientkernelModulesApi.IService);
        tripleRedHotSevensIXFGameController.Factory = ck_implements(tripleRedHotSevensIXFGameController.Factory, componentmodelComponentApi.IComponentFactory);
        tripleRedHotSevensIXFGameController.Factory.__interfaces__ = [clientkernelModulesApi.IService, componentmodelComponentApi.IComponentFactory];
        tripleRedHotSevensIXFGameController.Factory.__name__ = ["tripleRedHotSevensIXFGameController", "Factory"];
        tripleRedHotSevensIXFGameController.Factory.prototype.stateMachine = null;
        tripleRedHotSevensIXFGameController.Factory.prototype.smDispatcher = null;
        tripleRedHotSevensIXFGameController.Factory.prototype.smContext = null;
        tripleRedHotSevensIXFGameController.Factory.prototype.createComponent = function(context) {
            var _g = this;
            this.setupStateMachineContext();
            var gameController;
            gameController = new tripleRedHotSevensIXFGameController.GameController(tripleRedHotSevensIXFGameController.ExternalService.logger, this.stateMachine, this.smDispatcher, this.smContext);
            this.smContext.setupContextData(gameController);
            new components.gamecontroller.imp.GameLoader(context).load(function(loader) {
                loader.apply(gameController);
                _g.setupStateMachine();
                var model = loader.getModel();
                var soundControllerLogger = tripleRedHotSevensIXFGameController.ExternalService.loggerFactory.getLogger("SoundController");
                new soundEventTool.SoundController(context, tripleRedHotSevensIXFGameController.ExternalService.assetRegistry, soundControllerLogger, [tripleRedHotSevensIXFGameController.ExternalService.busChanel], model);
            });
        };
        tripleRedHotSevensIXFGameController.Factory.prototype.getComponentDeclaration = function() {
            return tripleRedHotSevensIXFComponentsGameControllerApi.GameControllerDeclaration;
        };
        tripleRedHotSevensIXFGameController.Factory.prototype.setupStateMachineContext = function() {
            this.smDispatcher = new stateMachineEngine.EventDispatcher();
            this.smContext = new tripleRedHotSevensIXFGameController.StateMachineContext(this.smDispatcher);
            this.stateMachine = new stateMachineEngine.StateMachine(this.smDispatcher, tripleRedHotSevensIXFGameController.StateMachineDef.ID);
            this.stateMachine.logLevel = 3;
            this.stateMachine.logPrefix = "[GAME_CONTROLLER]";
            this.stateMachine.dispatchGlobalStateChange = false;
        };
        tripleRedHotSevensIXFGameController.Factory.prototype.setupStateMachine = function() {
            this.stateMachine.setContext(this.smContext);
            stateMachineEngine.StateMachine.logger = tripleRedHotSevensIXFGameController.ExternalService.logger;
            stateMachineEngine.FSMInjector.registerSM(this.stateMachine, tripleRedHotSevensIXFGameController.StateMachineDef.FSM);
        };
        tripleRedHotSevensIXFGameController.Factory.prototype.__class__ = tripleRedHotSevensIXFGameController.Factory;
        if (typeof components == 'undefined') {
            var components = {};
        };
        if (!components.gamecontroller) {
            components.gamecontroller = {};
        };
        if (!components.gamecontroller.imp) {
            components.gamecontroller.imp = {};
        };
        components.gamecontroller.imp.GameLoader = function(context) {
            this.gameLoadingCollector = new commonTools.EnumConditionsCollector(tripleRedHotSevensIXFGameController.GameLoadCriteria);
            var _g = this;
            this.context = context;
            this.gameLayoutControl = null;
            this.model = new tripleRedHotSevensIXFGameController.GameModel();
            this.controlsInjector = new commonControls.ControlsInjector(context);
            this.controlsInjector.registerCustomInject("model", function() {
                return _g.model;
            });
            this.controlsInjector.registerInject(tripleRedHotSevensIXFGameController.WinMeterController, (function(f, a1) {
                return function() {
                    return f(a1);
                };
            })(($_ = this.controlsInjector, $bind($_, $_.inject)), new tripleRedHotSevensIXFGameController.WinMeterController(null)));
            this.controlsInjector.registerInject(tripleRedHotSevensIXFGameController.SkipController, (function(f1, a11) {
                return function() {
                    return f1(a11);
                };
            })(($_ = this.controlsInjector, $bind($_, $_.inject)), new tripleRedHotSevensIXFGameController.SkipController(null)));
        };
        components.gamecontroller.imp.GameLoader.__name__ = ["components", "gamecontroller", "imp", "GameLoader"];
        components.gamecontroller.imp.GameLoader.prototype.slotModelPort = null;
        components.gamecontroller.imp.GameLoader.prototype.gameLayoutControl = null;
        components.gamecontroller.imp.GameLoader.prototype.model = null;
        components.gamecontroller.imp.GameLoader.prototype.gameLoadingCollector = null;
        components.gamecontroller.imp.GameLoader.prototype.context = null;
        components.gamecontroller.imp.GameLoader.prototype.controlsInjector = null;
        components.gamecontroller.imp.GameLoader.prototype.load = function(callbackFunction) {
            var _g = this;
            this.controlsInjector.inject(this);
            this.gameLoadingCollector.then(function() {
                _g.slotModelPort.getStages().getInitStage().getGameLoaded().publish(null);
                callbackFunction(_g);
                _g.correctMobileGameCanvases();
            });
            this.context.getStarted().then(function(a) {
                _g.gameLoadingCollector.resolveCondition(tripleRedHotSevensIXFGameController.GameLoadCriteria.ASSEMBLY_STARTED);
            });
            tripleRedHotSevensIXFGameController.ExternalService.assetRegistry.getAsset("game-config_json").getContent().then(function(data) {
                _g.gameLoadingCollector.resolveCondition(tripleRedHotSevensIXFGameController.GameLoadCriteria.CONFIG_LOADED);
                _g.model.setGameConfig(data.gameControllerConfig);
            });
            this.gameLayoutControl.onGameLayoutUpdated(function() {
                _g.gameLoadingCollector.resolveCondition(tripleRedHotSevensIXFGameController.GameLoadCriteria.LAYOUT_UPDATED);
                _g.correctMobileGameCanvases();
            });
        };
        components.gamecontroller.imp.GameLoader.prototype.correctMobileGameCanvases = function() {
            if (tripleRedHotSevensIXFGameController.ExternalService.isDevice() && this.model.config != null) {
                var topOffset = this.model.config.mobilePanelHeight;
                new commonTools.CanvasCorrector().correctGameCanvases(topOffset);
            }
        };
        components.gamecontroller.imp.GameLoader.prototype.apply = function(controller) {
            this.controlsInjector.inject(controller);
        };
        components.gamecontroller.imp.GameLoader.prototype.getModel = function() {
            return this.model;
        };
        components.gamecontroller.imp.GameLoader.prototype.__class__ = components.gamecontroller.imp.GameLoader;
        tripleRedHotSevensIXFGameController.GameController = function(logger, stateMachine, smDispatcher, smContext) {
            this.isTutorialOnScreen = false;
            this.outcomePresentedSent = true;
            this.paytableOpened = false;
            this.promotionalSpinsActive = false;
            this.stateMachine = stateMachine;
            this.smDispatcher = smDispatcher;
            this.smContext = smContext;
            this.logger = logger;
            logger.info("STARTED");
            this.storage = new commonTools.LocalStorage(tripleRedHotSevensIXFGameController.GameController.STORAGE_PREFIX);
        };
        tripleRedHotSevensIXFGameController.GameController.__name__ = ["tripleRedHotSevensIXFGameController", "GameController"];
        tripleRedHotSevensIXFGameController.GameController.prototype.stateMachine = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.smDispatcher = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.smContext = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.model = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.storage = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.stopReelsConditions = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.promotionalSpinsActive = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.paytableOpened = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.outcomePresentedSent = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.promotionalSpinsCount = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.logger = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.resultPayload = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.skipController = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.winMeterController = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.slotModelPort = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.popupsPort = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.tutorialPort = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.animationPort = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.betPanelControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.reelsControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.winMeterControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.winControllerControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.infoBarControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.paytableControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.backgroundControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.gameLayoutControl = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.autoplayController = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.isTutorialOnScreen = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.minRTP = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.maxRTP = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.singleRTP = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.maxSingleRTP = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.awardCap = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.Iframe = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.payLines = null;
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchEvent = function(action) {
            this.smDispatcher.dispatchEvent(new stateMachineEngine.StateEvent(tripleRedHotSevensIXFGameController.StateMachineDef.ID + stateMachineEngine.StateEvent.ACTION, action));
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.attachComponents = function() {
            this.logger.info("attachComponents");
            this.slotModelPort.getGameContext().getBalance().subscribe($bind(this, this.onBalanceUpdate));
            this.slotModelPort.getStages().getInitStage().getInitializeGamePhase().getInitializeGame().subscribe($bind(this, this.onSlotModelInitGame));
            this.slotModelPort.getStages().getResumeStage().getPrepareResume().subscribe($bind(this, this.onPrepareResume));
            this.slotModelPort.getStages().getIdleStage().getConfirmSelectedStake().subscribe($bind(this, this.onConfirmSelectedStake));
            this.slotModelPort.getStages().getIdleStage().getOpenPaytable().subscribe($bind(this, this.onOpenPaytable));
            this.slotModelPort.getStages().getSpinStage().getStartReelSpin().subscribe($bind(this, this.onModelSpinStart));
            this.slotModelPort.getStages().getSpinStage().getOutcomePhase().getSpinOutcome().subscribe($bind(this, this.onSpinOutcome));
            this.slotModelPort.getStages().getSpinStage().getStopReelSpin().subscribe($bind(this, this.onModelSpinStop));
            this.slotModelPort.getStages().getSpinStage().getOutcomePhase().getPresentSpinOutcome().subscribe($bind(this, this.onSpinOutcomePresent));
            this.slotModelPort.getStages().getResultStage().getPresentResult().subscribe($bind(this, this.onPresentResult));
            this.slotModelPort.getStages().getAbortStage().getAbortSpin().subscribe($bind(this, this.onAbortSpin));
            this.slotModelPort.getGameCommands().getSpinCommandAvailable().subscribe($bind(this, this.onSpinCommandAvailable));
            this.slotModelPort.getGameCommands().getContinueCommandAvailable().subscribe($bind(this, this.onContinueCommandAvailable));
            this.slotModelPort.getGameCommands().getPaytableCommandAvailable().subscribe($bind(this, this.onPaytableCommandAvailable));
            this.slotModelPort.getGameCommands().getStakeCommandAvailable().subscribe($bind(this, this.onStakeCommandAvailable));
            this.betPanelControl.onButtonPressed($bind(this, this.onBetPanelButtonPressed));
            this.betPanelControl.onStakeChanged($bind(this, this.onBetPanelStakeChanged));
            this.reelsControl.onReelStopped($bind(this, this.onReelStopped));
            this.reelsControl.onSpinStopped($bind(this, this.onSpinStopped));
            this.reelsControl.onStoppingStarted($bind(this, this.onReelStoppingStarted));
            this.reelsControl.onStartSpinReelPictureExit($bind(this, this.onReelOutcomeExit));
            this.paytableControl.onPaytableClose($bind(this, this.onPaytableClose));
            this.tutorialPort.onCloseClicked($bind(this, this.onTutorialClose));
            this.tutorialPort.onCheckBoxChanged($bind(this, this.onTutorialCheckboxChange));
            this.popupsPort.onButtonClicked($bind(this, this.onFreeSpinIntroStartClicked));
            this.popupsPort.onButtonEnabled($bind(this, this.onFreeSpinIntroEnabled));
            this.autoplayController = new tripleRedHotSevensIXFGameController.AutoplayController(this.betPanelControl, this.slotModelPort);
            window.addEventListener("closeHelp", $bind(this, this.closeHelp));
            window.addEventListener("closePaytable", $bind(this, this.onHTMLPaytableClose));
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.initGame = function() {
            this.initHotKeys();
            this.slotModelPort.getStages().getInitStage().getGameInitialized().publish(null);
            if (tripleRedHotSevensIXFGameController.ExternalService.isMini()) this.slotModelPort.getGameContext().getGameOptionChangedFromGf().publish(new slotModelApi.Pair("sound", "1"));
            this.winMeterControl.clear();
            this.animationPort.hide(animationPort.AnimationComponent.SPITFIRE_MULTIPLIERS_LOGO);
            this.infoBarControl.hideAll();
            this.showOrSkipTutorial();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showOrSkipTutorial = function() {
            var _g = this;
            this.storage.writeOptionIfNotExists(tripleRedHotSevensIXFGameController.GameController.SKIP_TUTORIAL_OPTION, "false");
            var skipTutorial = this.storage.readOption(tripleRedHotSevensIXFGameController.GameController.SKIP_TUTORIAL_OPTION, "false");
            tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish("skippingTutorial:" + skipTutorial, null);
            tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish("testable:testcomponent:tutorialConfirmed", skipTutorial);
            if (skipTutorial == "false") _hcmn_.haxe_Timer.delay(function() {
                _g.tutorialPort.show();
                _g.isTutorialOnScreen = true;
                _g.gameLayoutControl.hideLayers("tutorial");
            }, 0);
            else {
                this.betPanelControl.showSpinButton();
                this.tutorialPort.hide();
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.prepareResume = function() {
            this.initHotKeys();
            if (tripleRedHotSevensIXFGameController.ExternalService.isMini()) this.slotModelPort.getGameContext().getGameOptionChangedFromGf().publish(new slotModelApi.Pair("sound", "1"));
            this.infoBarControl.hideAll();
            this.winMeterControl.clear();
            this.winMeterController.showImmediately(this.model.spinOutcome.acumulatedPayout);
            this.betPanelControl.showSpinButton(false);
            this.betPanelControl.disableButton(betPanelApi.EButton.TOTAL_BET);
            this.betPanelControl.disableButton(betPanelApi.EButton.PAYTABLE);
            this.updateFreeSpinsBetPanel();
            this.animationPort.hide(animationPort.AnimationComponent.SPITFIRE_MULTIPLIERS_LOGO);
            this.animationPort.updateFreeSpinWin(this.model.getFreeSpinsTotalWin());
            _hcmn_.haxe_Timer.delay($bind(this, this.showResumePopup), 0);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onFreeSpinIntroEnabled = function(e) {
            if (this.model.isResume) this.slotModelPort.getStages().getResumeStage().getResumePrepared().publish(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showResumePopup = function() {
            this.popupsPort.showFreeSpinIntro(0);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onBaseGameIdle = function() {
            this.betPanelControl.showSpinButton();
            this.updatePromoSpinsCounter();
            if (!this.model.hasWinInOutcome()) this.animationPort.playLogo();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.updateFreeSpinsBetPanel = function() {
            this.animationPort.updateFreeSpinCounter(this.model.getNextFreeSpin());
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.clearAllWins = function() {
            this.model.setAbortSpinPayload(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.startSpin = function() {
            this.animationPort.pauseLogo();
            this.betPanelControl.showSpinButton(false);
            this.betPanelControl.setCustomButtonState(betPanelApi.EButton.SPIN, betPanelApi.CustomButtonStatePayload.CONNECTING_STATE);
            this.forcePaytableClose();
            this.reelsControl.startSpin(this.model.startSpinPayload);
            this.setReelStopConditions();
            if (this.smContext.isNextFreeSpin()) {
                this.animationPort.showReelFire();
                this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_MULTIPLIER);
            }
            this.winMeterControl.showMessage(tripleRedHotSevensIXFGameController.ExternalService.translationManager.stringLookup("GoodLuck"));
            this.model.isBonusSummary = false;
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setReelStopConditions = function() {
            this.stopReelsConditions = new commonTools.EnumConditionsCollector(tripleRedHotSevensIXFGameController.StopReelsCondition).then($bind(this, this.dispatchStopReels));
            if (!this.smContext.isNextFreeSpin()) this.stopReelsConditions.resolveCondition(tripleRedHotSevensIXFGameController.StopReelsCondition.MULTIPLIER_FINISHED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.checkForStopOrAbort = function() {
            if (this.model.abortSpinPayload != null) {
                this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.ABORT_SPIN);
                this.stopReelsConditions.clearAll();
            } else this.stopReelsConditions.resolveCondition(tripleRedHotSevensIXFGameController.StopReelsCondition.SPINNING_STARTED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchStopReels = function() {
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.STOP_REEL_SPIN);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.applyAbortData = function() {
            this.betPanelControl.setCustomButtonState(betPanelApi.EButton.SPIN, betPanelApi.CustomButtonStatePayload.CONNECTED_STATE);
            this.applyStakeItemsWithTotalBet(this.model.abortSpinPayload.stake);
            this.betPanelControl.disableButton(betPanelApi.EButton.TOTAL_BET);
            this.model.setOutcome(this.model.abortSpinPayload.stake.outcome);
            this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
            this.winMeterControl.clear();
            this.publishSpinAborted();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.publishSpinAborted = function() {
            this.slotModelPort.getStages().getAbortStage().getSpinAborted().publish(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.stopReels = function() {
            this.reelsControl.stopSpin(this.model.outcome.reelStop.reels, this.model.tensionReels);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showBaseGameOutcome = function() {
            this.outcomePresentedSent = false;
            if (this.model.hasWinInOutcome()) {
                var outcome = this.model.spinOutcome.baseGame.outcome;
                var isHighWin = true;
                if (this.model.rgPresentation) {
                    if (!this.model.isHighWin()) isHighWin = false;
                }
                var skipPromise = this.skipController.show();
                var winMeterPromise = this.winMeterController.show(outcome.totalPayout, outcome.bigWin, isHighWin);
                if (tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService == null) tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin();
                ((function($this) {
                    var $r;
                    var this1 = tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService.getAllPlugins();
                    $r = this1.get("WIN_LINES_ADAPTATION_PLUGIN");
                    return $r;
                }(this))).setCurrentWin(this.setHighWin(this.model.isHighWin()), null);
                var winLinesPromise = this.winControllerControl.showWin(outcome);
                var winMeterOrSkipPromise = Promise.race([skipPromise, winMeterPromise]);
                winMeterOrSkipPromise.then($bind(this, this.onWinMeterFinished));
                if (this.autoplayController.isActiveNotLast()) Promise.all([winLinesPromise, winMeterOrSkipPromise]).then($bind(this, this.onWinOutcomeShown));
            } else if (this.autoplayController.isActiveNotLast()) {
                this.betPanelControl.showSpinButton(true);
                _hcmn_.haxe_Timer.delay($bind(this, this.checkSendOutcomePresented), this.model.config.nextAutoSpinOnLossDelay);
            } else this.checkSendOutcomePresented();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onWinMeterFinished = function(data) {
            this.skipController.hide(this.autoplayController.isActiveNotLast());
            this.winMeterController.stop();
            if (!this.autoplayController.isActiveNotLast()) this.checkSendOutcomePresented();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onWinOutcomeShown = function(data) {
            _hcmn_.haxe_Timer.delay($bind(this, this.checkSendOutcomePresented), this.model.config.nextAutoSpinOnWinDelay);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showFreeSpinSummary = function() {
            var _g = this;
            var baseGameOutcome = this.model.spinOutcome.baseGame.outcome;
            var freeSpinsPayout = this.model.spinOutcome.acumulatedFreeSpinPayout;
            var summaryOutcome = tripleRedHotSevensIXFGameController.OutcomeHelper.getAsFreeSpinSummaryOutcome(baseGameOutcome, freeSpinsPayout);
            this.model.setOutcome(summaryOutcome);
            var isHighWin = true;
            if (this.model.rgPresentation) {
                if (!this.model.isHighWin()) isHighWin = false;
            }
            if (tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService == null) tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin();
            ((function($this) {
                var $r;
                var this1 = tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService.getAllPlugins();
                $r = this1.get("WIN_LINES_ADAPTATION_PLUGIN");
                return $r;
            }(this))).setCurrentWin(this.setHighWin(this.model.isHighWin()), null);
            this.winControllerControl.showWin(this.model.outcome);
            var skipPromise = this.skipController.show();
            var winMeterPromise = this.winMeterController.show(this.resultPayload.totalWin, this.resultPayload.bigWin, isHighWin);
            Promise.race([skipPromise, winMeterPromise]).then(function(data) {
                _g.skipController.hide();
                _g.winMeterController.stop();
                _g.dispatchContinueAction();
            });
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.checkSendOutcomePresented = function() {
            if (!this.outcomePresentedSent) {
                this.publishSpinOutcomePresented();
                this.outcomePresentedSent = true;
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.publishSpinOutcomePresented = function() {
            this.slotModelPort.getStages().getSpinStage().getOutcomePhase().getSpinOutcomePresented().publish(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.publishResultPresented = function() {
            this.slotModelPort.getStages().getResultStage().getResultPresented().publish(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.prepareAwardCap = function() {
            var _g = this;
            _hcmn_.haxe_Timer.delay(function() {
                _g.publishSpinOutcomePresented();
                _g.setBaseGameOutcome();
            }, this.model.config.awardCapPopupDelay);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showAwardCapScreen = function() {
            if (this.smContext.isFreeSpin()) this.switchToBaseGame();
            this.infoBarControl.hideAll();
            this.autoplayController.stop();
            this.skipController.show().then($bind(this, this.onSkipAwardCap));
            var maxValue = tripleRedHotSevensIXFGameController.ExternalService.moneyFormatter.format(this.model.spinOutcome.acumulatedPayout);
            this.popupsPort.showAwardCap(maxValue, this.smContext.isFreeSpin());
            this.winMeterController.showImmediately(this.model.spinOutcome.acumulatedPayout);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSkipAwardCap = function(data) {
            this.hidePopup();
            this.updatePromoSpinsCounter();
            this.skipController.hide();
            this.dispatchContinueAction();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchContinueAction = function() {
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.CONTINUE);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.hidePopup = function() {
            this.popupsPort.hide();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showScatterWins = function() {
            var _g = this;
            this.infoBarControl.hideAll();
            var bigWin = tripleRedHotSevensIXFGameController.OutcomeHelper.reduceBigWin(this.model.outcome.bigWin);
            var isHighWin = true;
            if (this.model.rgPresentation) {
                if (!this.model.isHighWin()) isHighWin = false;
            }
            this.winMeterController.show(this.model.outcome.totalPayout, bigWin, isHighWin);
            var outcome = tripleRedHotSevensIXFGameController.OutcomeHelper.getAsScattersOutcome(this.model.outcome);
            if (tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService == null) tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin();
            ((function($this) {
                var $r;
                var this1 = tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService.getAllPlugins();
                $r = this1.get("WIN_LINES_ADAPTATION_PLUGIN");
                return $r;
            }(this))).setCurrentWin(this.setHighWin(this.model.isHighWin()), null);
            this.winControllerControl.showWin(outcome).then(function(data) {
                _g.winControllerControl.hide();
                _g.reelsControl.setReelPicture(_g.model.outcome.reelStop.reels);
                _g.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.FS_ENTRY_SHOWN);
            });
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.startFSIntroAnim = function() {
            this.popupsPort.showFreeSpinIntro(this.model.spinOutcome.freeSpin.awarded);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onFreeSpinIntroStartClicked = function(e) {
            this.dispatchFSIntroEndedAction();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchFSIntroEndedAction = function() {
            this.hidePopup();
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.FS_INTRO_ENDED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.prepareFreeSpin = function() {
            this.model.setOutcome(this.model.spinOutcome.freeSpin.outcome);
            this.reelsControl.setReelPicture(this.model.spinOutcome.freeSpin.outcome.reelStop.reels);
            this.switchToFreeSpins();
            this.winMeterControl.clear();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.switchToFreeSpins = function() {
            this.backgroundControl.show("fsBkg");
            this.animationPort.hide(animationPort.AnimationComponent.BASE_GAME_BACK_FIRE);
            this.animationPort.updateFreeSpinCounter(this.model.getNextFreeSpin());
            this.animationPort.show(animationPort.AnimationComponent.SPITFIRE_MULTIPLIERS_LOGO);
            this.animationPort.showReelFire();
            this.animationPort.show(animationPort.AnimationComponent.FREE_SPIN_PANEL);
            this.animationPort.pauseLogo();
            this.gameLayoutControl.hideLayers("freeSpins");
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showFreeSpinOutcome = function() {
            var _g = this;
            var hasWinPresentation = this.model.hasWinInOutcome();
            if (tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService == null) tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin();
            ((function($this) {
                var $r;
                var this1 = tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService.getAllPlugins();
                $r = this1.get("WIN_LINES_ADAPTATION_PLUGIN");
                return $r;
            }(this))).setCurrentWin(this.setHighWin(this.model.isHighWin()), null);
            var showWinPromise = this.winControllerControl.showWin(this.model.outcome);
            if (hasWinPresentation) {
                this.animationPort.updateFreeSpinWin(this.model.getFreeSpinsTotalWin());
                var skipPromise = this.skipController.show();
                Promise.race([skipPromise, showWinPromise]).then(function(data) {
                    _g.reelsControl.setReelPicture(_g.model.outcome.reelStop.reels);
                    _g.winControllerControl.hide();
                    _g.skipController.hide();
                    _g.dispatchFSOutcomeDone();
                });
            } else {
                showWinPromise = null;
                this.dispatchFSOutcomeDone(this.model.config.fs_NoWinSpinDelay);
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchFSOutcomeDone = function(delayBeforeOutro) {
            if (delayBeforeOutro == null) delayBeforeOutro = 0;
            var _g = this;
            if (this.smContext.isNextFreeSpin()) this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTCOME_DONE);
            else _hcmn_.haxe_Timer.delay(function() {
                _g.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTCOME_DONE);
            }, delayBeforeOutro);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showRetriggerScreen = function() {
            var freeSpinsOutcome = this.model.spinOutcome.freeSpin;
            this.popupsPort.showRetrigger(freeSpinsOutcome.total, freeSpinsOutcome.awarded, freeSpinsOutcome.isMaxAwarded);
            this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_REEL_FIRE);
            this.animationPort.updateFreeSpinCounter(this.model.getCurrentFreeSpin());
            _hcmn_.haxe_Timer.delay($bind(this, this.dispatchRetriggerShownAction), this.model.config.fs_MaxRetriggerScreenDuration);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchRetriggerShownAction = function() {
            this.hidePopup();
            this.animationPort.showReelFire(this.model.multiplier);
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.RETRIGGER_SHOWN);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.startFSOutroAnim = function() {
            this.model.isBonusSummary = true;
            this.model.isFSOutroPopup = true;
            if (tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService == null) tripleRedHotSevensIXFGameController.ExternalService.initWinControllerPlugin();
            ((function($this) {
                var $r;
                var this1 = tripleRedHotSevensIXFGameController.ExternalService.winControllerPluginService.getAllPlugins();
                $r = this1.get("WIN_LINES_ADAPTATION_PLUGIN");
                return $r;
            }(this))).setCurrentWin(this.setHighWin(this.model.isHighWin()), null);
            this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_REEL_FIRE);
            this.popupsPort.showFreeSpinOutro(this.model.getFreeSpinsTotalWin("0"));
            _hcmn_.haxe_Timer.delay($bind(this, this.dispatchFSOutroEndAction), this.model.config.fs_SummaryDuration);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.switchToBaseGame = function() {
            this.backgroundControl.show("mainBkg");
            this.animationPort.show(animationPort.AnimationComponent.BASE_GAME_BACK_FIRE);
            this.animationPort.hide(animationPort.AnimationComponent.SPITFIRE_MULTIPLIERS_LOGO);
            this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_REEL_FIRE);
            this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_PANEL);
            this.animationPort.hide(animationPort.AnimationComponent.FREE_SPIN_MULTIPLIER);
            this.animationPort.playLogo();
            this.gameLayoutControl.unHideLayers();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.dispatchFSOutroEndAction = function() {
            this.hidePopup();
            this.switchToBaseGame();
            this.model.isFSOutroPopup = false;
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTRO_END);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setBaseGameOutcome = function() {
            this.model.setOutcome(this.model.spinOutcome.baseGame.outcome);
            this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.executeContinueCommand = function() {
            this.logger.info("executeContinueCommand:stage:" + this.model.spinOutcome.stage);
            var delay = this.model.getDelayForExecuteContinueCommand();
            var continueCommandExecuted = this.slotModelPort.getGameCommands().getContinueCommandExecuted();
            _hcmn_.haxe_Timer.delay(function() {
                continueCommandExecuted.publish(null);
            }, delay);
            this.model.isResume = false;
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onBalanceUpdate = function(e) {
            var payload = e.getPayload();
            this.setPromoFreeSpins(payload.freespin);
            this.updateBalanceOnPanel(payload.balance);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setPromoFreeSpins = function(remainingCount) {
            this.promotionalSpinsActive = remainingCount != null;
            this.promotionalSpinsCount = remainingCount;
            if (this.promotionalSpinsActive) {
                this.updatePromoSpinsCounter();
                this.betPanelControl.setBalance(tripleRedHotSevensIXFGameController.ExternalService.translationManager.stringLookup("BalanceValueNotAvailable"));
                this.betPanelControl.disableButton(betPanelApi.EButton.TOTAL_BET);
            } else this.infoBarControl.hideAll();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.updateBalanceOnPanel = function(value) {
            if (!this.promotionalSpinsActive) this.betPanelControl.setBalance(value);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSlotModelInitGame = function(e) {
            var _g = this;
            this.logger.info("onSlotModelInitGame");
            this.model.setSlotDefinition(e.getPayload().slotDefinition);
            this.model.isResume = false;
            this.model.rgPresentation = e.getPayload().riskControlSettings.rgPresentation;
            this.applyStakeItemsWithTotalBet(e.getPayload().defaultStake);
            this.model.setOutcome(e.getPayload().defaultStake.outcome);
            this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
            this.betPanelControl.showSpinButton();
            this.minRTP = e.getPayload().slotDefinition.rtp.minRTP;
            this.maxRTP = e.getPayload().slotDefinition.rtp.maxRTP;
            this.maxSingleRTP = e.getPayload().slotDefinition.rtp.maxSingleRTP;
            this.singleRTP = e.getPayload().slotDefinition.rtp.singleRTP;
            this.awardCap = e.getPayload().riskControlSettings.awardCap;
            var decimalSeparator = tripleRedHotSevensIXFGameController.ExternalService.translationManager.stringLookup("rtpDecimalSeparator");
            if (decimalSeparator != null && decimalSeparator != "rtpDecimalSeparator") {
                if (this.minRTP != null) this.minRTP = _hcmn_.StringTools.replace(this.minRTP, ".", decimalSeparator);
                else this.minRTP = null;
                if (this.maxRTP != null) this.maxRTP = _hcmn_.StringTools.replace(this.maxRTP, ".", decimalSeparator);
                else this.maxRTP = null;
                if (this.maxSingleRTP != null) this.maxSingleRTP = _hcmn_.StringTools.replace(this.maxSingleRTP, ".", decimalSeparator);
                else this.maxSingleRTP = null;
            }
            this.payLines = this.model.parsePayLines(tripleRedHotSevensIXFGameController.Data.PatternInfo);
            var iframe = window.document.getElementById("paytableInstance").firstChild;
            iframe.onload = function() {
                _g.Iframe = iframe;
                _g.placePaytableTexts();
                _g.createPaylinesTables("baseGame", "bg", 3, 3, 1);
            };
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.INIT_ACTION);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.placePaytableTexts = function() {
            this.setRTPValues();
            this.setAwardCapValue();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setRTPValues = function() {
            if (this.singleRTP != null && this.singleRTP) {
                this.setPaytableText("multipleRTP", "", "display:none;");
                this.setPaytableText("maxSingleRTP", this.maxSingleRTP);
            } else {
                this.setPaytableText("singleRTP", "", "display:none;");
                this.setPaytableText("minRTP", this.minRTP);
                this.setPaytableText("maxRTP", this.maxRTP);
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setAwardCapValue = function() {
            var showDecimalValueInAwardCap = true;
            var formattedAwardCap = tripleRedHotSevensIXFGameController.ExternalService.moneyFormatter.format(this.awardCap, true, showDecimalValueInAwardCap);
            this.setPaytableText("awardcap", formattedAwardCap);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setPaytableText = function(div, texts, style) {
            var paytableDiv = this.Iframe.contentDocument.getElementById(div);
            if (paytableDiv != null) {
                paytableDiv.innerText = texts;
                if (style != null) paytableDiv.setAttribute("style", style);
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onPrepareResume = function(e) {
            this.logger.info("onPrepareResume");
            this.model.isResume = true;
            var resumePayload = e.getPayload();
            this.model.rgPresentation = resumePayload.initializationProperties.riskControlSettings.rgPresentation;
            this.model.rgPresentation = true;
            this.model.setSlotDefinition(resumePayload.initializationProperties.slotDefinition);
            this.model.setSpinOutcome(resumePayload.spinOutcome);
            this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
            this.applyStakeItemsWithTotalBet(resumePayload.stake);
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.PREPARE_RESUME);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onConfirmSelectedStake = function(e) {
            this.winMeterControl.clear();
            if (!this.isTutorialOnScreen) {
                if (this.winControllerControl.isActive()) this.animationPort.playLogo();
                this.winControllerControl.hide();
                this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
            }
            this.applyStakeItemsWithTotalBet(e.getPayload());
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.applyStakeItemsWithTotalBet = function(stake) {
            this.logger.info("applyStakeItemsWithTotalBet");
            this.model.setCurrentStake(stake);
            this.betPanelControl.setStake(stake);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSpinCommandAvailable = function(e) {
            var spinAvailable = e.getPayload();
            this.betPanelControl.showSpinButton(spinAvailable);
            if (spinAvailable) this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.SPIN_ENABLED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onStakeCommandAvailable = function(e) {
            if (!e.getPayload()) this.betPanelControl.disableButton(betPanelApi.EButton.TOTAL_BET);
            else if (!this.promotionalSpinsActive) this.betPanelControl.enableButton(betPanelApi.EButton.TOTAL_BET);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onModelSpinStart = function(e) {
            this.model.setStartSpinPayload(e.getPayload());
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.START_REEL_SPIN);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSpinOutcome = function(e) {
            this.model.setSpinOutcome(e.getPayload());
            this.betPanelControl.setCustomButtonState(betPanelApi.EButton.SPIN, betPanelApi.CustomButtonStatePayload.CONNECTED_STATE);
            this.smContext.setContextValue("Stage", e.getPayload().stage);
            this.smContext.setContextValue("NextStage", e.getPayload().nextStage);
            this.smContext.setContextValue("awardCapExceeded", e.getPayload().awardCapExceeded);
            if (e.getPayload().stage == "FreeSpin") this.smContext.setContextValue("retrigger", this.model.spinOutcome.freeSpin.isIncrementTriggered);
            if (this.smContext.isFreeSpin()) this.showMultiplier();
            this.prepareReelStopSounds();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.showMultiplier = function() {
            var _g = this;
            this.animationPort.showMultiplier(this.model.multiplier);
            _hcmn_.haxe_Timer.delay(function() {
                _g.animationPort.showReelFire(_g.model.multiplier);
            }, this.model.config.timeForColorToReachReels);
            _hcmn_.haxe_Timer.delay(function() {
                _g.stopReelsConditions.resolveCondition(tripleRedHotSevensIXFGameController.StopReelsCondition.MULTIPLIER_FINISHED);
            }, this.model.config.freeSpinStopReelsDelay);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.prepareReelStopSounds = function() {
            var _g1 = 0;
            var _g = this.model.reelsNum;
            while (_g1 < _g) {
                var reelId = _g1++;
                if (this.model.isActiveWildOnReel(reelId)) tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish("unlockSmartSoundForWild" + reelId, null);
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onModelSpinStop = function(e) {
            this.stopReelsConditions.resolveCondition(tripleRedHotSevensIXFGameController.StopReelsCondition.STOP_RECEIVED);
            if (this.stateMachine.isInState(tripleRedHotSevensIXFGameController.StateMachineDef.SPINNING_STATE)) this.stopReelsConditions.resolveCondition(tripleRedHotSevensIXFGameController.StopReelsCondition.SPINNING_STARTED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onAbortSpin = function(e) {
            this.model.setAbortSpinPayload(e.getPayload());
            if (this.stateMachine.isInState(tripleRedHotSevensIXFGameController.StateMachineDef.SPINNING_STATE)) this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.ABORT_SPIN);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSpinOutcomePresent = function(e) {
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.PRESENT_SPIN_OUTCOME);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onPresentResult = function(e) {
            this.resultPayload = e.getPayload();
            this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.PRESENT_RESULT);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onContinueCommandAvailable = function(e) {
            if (e.getPayload()) this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.CONTINUE_ENABLED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onPaytableCommandAvailable = function(e) {
            this.betPanelControl.enableButton(betPanelApi.EButton.PAYTABLE, e.getPayload());
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onOpenPaytable = function(e) {
            this.logger.info("onOpenPaytable");
            this.hidePopup();
            if (this.paytableOpened) {
                this.onPaytableClose();
                return;
            }
            this.paytableOpened = true;
            this.paytableControl.show();
            this.betPanelControl.disableButton(betPanelApi.EButton.TOTAL_BET);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onBetPanelButtonPressed = function(e) {
            var button = e.getPayload();
            switch (button[1]) {
                case 1:
                    this.onSpinButtonPressed();
                    break;
                case 5:
                    this.slotModelPort.getGameCommands().getPaytableCommandExecuted().publish(null);
                    break;
                case 9:
                    this.slotModelPort.getGameContext().getGameOptionChangedFromGf().publish(new slotModelApi.Pair("sound", "1"));
                    break;
                case 10:
                    this.slotModelPort.getGameContext().getGameOptionChangedFromGf().publish(new slotModelApi.Pair("sound", "0"));
                    break;
                case 13:
                    this.autoplayController.start();
                    break;
                case 14:
                    this.autoplayController.stop();
                    break;
                default:
                    this.logger.info("onBetPanelButtonPressed not handled for: " + button[0]);
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSpinButtonPressed = function() {
            this.betPanelControl.showSpinButton(false);
            this.checkSendOutcomePresented();
            if (!this.autoplayController.isActive()) this.slotModelPort.getGameCommands().getSpinCommandExecuted().publish(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onBetPanelStakeChanged = function(e) {
            this.slotModelPort.getGameCommands().getStakeCommandExecuted().publish(e.getPayload());
            this.createBetButtonClickedEvent(e.getPayload());
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.createBetButtonClickedEvent = function(stake) {
            var buttonClickedEvent = this.model.getBetPanelTopicForNewStakeItems(stake);
            tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish(buttonClickedEvent, null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onPaytableClose = function(e) {
            if (this.stateMachine.isInState(tripleRedHotSevensIXFGameController.StateMachineDef.IDLE_STATE)) {
                this.betPanelControl.showSpinButton();
                this.betPanelControl.enableButton(betPanelApi.EButton.TOTAL_BET);
            }
            this.paytableOpened = false;
            this.paytableControl.hide();
            this.reelsControl.show();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.forcePaytableClose = function() {
            this.logger.info("forcePaytableClose");
            this.paytableOpened = false;
            this.paytableControl.hide();
            this.reelsControl.show();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onHTMLPaytableClose = function(e) {
            this.onPaytableClose(null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.closeHelp = function() {
            tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish("paytable:hide", null);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onReelOutcomeExit = function(e) {
            this.logger.info("onReelOutcomeExit");
            if (e.getPayload() == 0) this.dispatchEvent(tripleRedHotSevensIXFGameController.StateMachineDef.SPIN_STARTING_ENDED);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onReelStoppingStarted = function(e) {
            this.logger.info("onReelStoppingStarted");
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onReelStopped = function(e) {
            var reelId = e.getPayload();
            this.logger.info("onReelStopped " + reelId);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onSpinStopped = function(e) {
            this.logger.info("GAME CONTROLLER onSpinStopped");
            if (this.stateMachine.isInState(tripleRedHotSevensIXFGameController.StateMachineDef.IDLE_STATE)) return;
            this.winMeterControl.clear();
            if (this.stateMachine.isInState(tripleRedHotSevensIXFGameController.StateMachineDef.STOPPING_STATE)) {
                this.slotModelPort.getStages().getSpinStage().getReelSpinFinished().publish(null);
                this.stopAutoSpinsIfPromoSpinsEnded();
            } else this.publishSpinAborted();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.stopAutoSpinsIfPromoSpinsEnded = function() {
            if (this.promotionalSpinsActive && this.promotionalSpinsCount == 0) this.autoplayController.stop();
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.updatePromoSpinsCounter = function() {
            if (this.promotionalSpinsActive) {
                var translationManager = tripleRedHotSevensIXFGameController.ExternalService.translationManager;
                var message = translationManager.stringLookup("PromotionalSpinsLeft") + " " + this.promotionalSpinsCount;
                this.infoBarControl.showCentralLabel(message);
                this.infoBarControl.showLeftLabel(" ");
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onTutorialClose = function() {
            this.tutorialPort.hide();
            this.gameLayoutControl.unHideLayers();
            this.isTutorialOnScreen = false;
            this.reelsControl.setReelPicture(this.model.outcome.reelStop.reels);
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.onTutorialCheckboxChange = function(e) {
            this.storage.writeOption(tripleRedHotSevensIXFGameController.GameController.SKIP_TUTORIAL_OPTION, "" + _hcmn_.Std.string(e.getPayload()));
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.setHighWin = function(isHighWin) {
            if (this.model.rgPresentation) {
                if (isHighWin) return "true";
                else return "false";
            } else return "true";
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.createPaylinesTables = function(elementId, type, rows, columns, offset) {
            var lineOffset = offset;
            var $it0 = this.payLines.keys();
            while ($it0.hasNext()) {
                var key = $it0.next();
                if (_hcmn_.StringTools.startsWith(key, type)) {
                    var div = this.Iframe.contentDocument.getElementById(elementId);
                    var tbl = this.Iframe.contentDocument.createElement("table");
                    tbl.setAttribute("border", "1");
                    var th = this.Iframe.contentDocument.createElement("th");
                    tbl.appendChild(th);
                    var _g = 0;
                    while (_g < rows) {
                        var k = _g++;
                        var tr = this.Iframe.contentDocument.createElement("tr");
                        var _g1 = 0;
                        while (_g1 < columns) {
                            var j = _g1++;
                            var td = this.Iframe.contentDocument.createElement("td");
                            tr.appendChild(td);
                            var _g2 = 0;
                            while (_g2 < columns) {
                                var z = _g2++;
                                var xx = this.payLines.get(key)[z].x;
                                var yy = this.payLines.get(key)[z].y - lineOffset;
                                if (xx == j && yy == k) td.setAttribute("class", "payline-color");
                            }
                        }
                        tbl.appendChild(tr);
                    }
                    th.setAttribute("colspan", "5");
                    div.appendChild(tbl);
                    th.setAttribute("id", "tHead" + key);
                    tbl.setAttribute("id", "table" + key);
                    th.appendChild(window.document.createTextNode(_hcmn_.Std.string(_hcmn_.HxOverrides.substr(key, 3, null))));
                }
            }
        };
        tripleRedHotSevensIXFGameController.GameController.prototype.initHotKeys = function() {};
        tripleRedHotSevensIXFGameController.GameController.prototype.__class__ = tripleRedHotSevensIXFGameController.GameController;
        tripleRedHotSevensIXFGameController.GameControllerConfig = function() {};
        tripleRedHotSevensIXFGameController.GameControllerConfig.__name__ = ["tripleRedHotSevensIXFGameController", "GameControllerConfig"];
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.nextAutoSpinOnLossDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.nextAutoSpinOnWinDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_IntroScreenDuration = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_FirstSpinDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_NoWinSpinDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.timeForColorToReachReels = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_RetriggerScreenDuration = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_MaxRetriggerScreenDuration = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.fs_SummaryDuration = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.freeSpinStopReelsDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.awardCapPopupDelay = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.mobilePanelHeight = null;
        tripleRedHotSevensIXFGameController.GameControllerConfig.prototype.__class__ = tripleRedHotSevensIXFGameController.GameControllerConfig;
        components.gamecontroller.imp.GameConfig = function() {};
        components.gamecontroller.imp.GameConfig.__name__ = ["components", "gamecontroller", "imp", "GameConfig"];
        components.gamecontroller.imp.GameConfig.prototype.gameControllerConfig = null;
        components.gamecontroller.imp.GameConfig.prototype.__class__ = components.gamecontroller.imp.GameConfig;
        tripleRedHotSevensIXFGameController.GameLoadCriteria = {
            __ename__: ["tripleRedHotSevensIXFGameController", "GameLoadCriteria"],
            __constructs__: ["ASSEMBLY_STARTED", "CONFIG_LOADED", "LAYOUT_UPDATED"]
        };
        tripleRedHotSevensIXFGameController.GameLoadCriteria.ASSEMBLY_STARTED = ["ASSEMBLY_STARTED", 0];
        tripleRedHotSevensIXFGameController.GameLoadCriteria.ASSEMBLY_STARTED.toString = $estr;
        tripleRedHotSevensIXFGameController.GameLoadCriteria.ASSEMBLY_STARTED.__enum__ = tripleRedHotSevensIXFGameController.GameLoadCriteria;
        tripleRedHotSevensIXFGameController.GameLoadCriteria.CONFIG_LOADED = ["CONFIG_LOADED", 1];
        tripleRedHotSevensIXFGameController.GameLoadCriteria.CONFIG_LOADED.toString = $estr;
        tripleRedHotSevensIXFGameController.GameLoadCriteria.CONFIG_LOADED.__enum__ = tripleRedHotSevensIXFGameController.GameLoadCriteria;
        tripleRedHotSevensIXFGameController.GameLoadCriteria.LAYOUT_UPDATED = ["LAYOUT_UPDATED", 2];
        tripleRedHotSevensIXFGameController.GameLoadCriteria.LAYOUT_UPDATED.toString = $estr;
        tripleRedHotSevensIXFGameController.GameLoadCriteria.LAYOUT_UPDATED.__enum__ = tripleRedHotSevensIXFGameController.GameLoadCriteria;
        tripleRedHotSevensIXFGameController.GameModel = function() {
            this.isFSOutroPopup = false;
            this.rgPresentation = false;
            this.moneyValueProvider = tripleRedHotSevensIXFGameController.ExternalService.moneyValueProvider;
        };
        tripleRedHotSevensIXFGameController.GameModel.__name__ = ["tripleRedHotSevensIXFGameController", "GameModel"];
        tripleRedHotSevensIXFGameController.GameModel.prototype.multiplier = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.bonusSymbolId = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.scatterSymbolId = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.wildSymbolId = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.spinOutcome = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.outcome = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.abortSpinPayload = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.startSpinPayload = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.tensionReels = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.cellsNum = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.reelsNum = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.stakeState = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.config = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.slotDefinition = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.isResume = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.moneyValueProvider = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.winLineAsTriggerForShowingAllLines = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.paylines = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.activePaylines = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.totalBet = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.rgPresentation = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.isBonusSummary = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.isFSOutroPopup = null;
        tripleRedHotSevensIXFGameController.GameModel.prototype.setSlotDefinition = function(slotDefinition) {
            this.slotDefinition = slotDefinition;
            var symbols = this.slotDefinition.symbols;
            var getSymbolId = function(s) {
                return s.id;
            };
            this.bonusSymbolId = symbols.filter(function(s2) {
                return s2.isBonus;
            }).map(getSymbolId)[0];
            this.scatterSymbolId = symbols.filter(function(s3) {
                return s3.isScatter;
            }).map(getSymbolId)[0];
            this.wildSymbolId = symbols.filter(function(s4) {
                return s4.isWild;
            }).map(getSymbolId)[0];
            var blankSymbolId = symbols.filter(function(s1) {
                return s1.description.indexOf("blank") >= 0;
            }).map(getSymbolId)[0];
            this.reelsNum = slotDefinition.reelPictureSize.reelCount;
            this.cellsNum = slotDefinition.reelPictureSize.reelLength;
            var winPath = new slotModelApi.ReelPictureInfo(this.getEmptyMatrix(0));
            this.winLineAsTriggerForShowingAllLines = new slotModelApi.LineWin(tripleRedHotSevensIXFGameController.GameModel.SPAGHETTI_LINE_WIN, 0, "0", 0, "0", winPath, blankSymbolId, 0, "trigger");
            var _g = [];
            var _g2 = 0;
            var _g1 = this.reelsNum;
            while (_g2 < _g1) {
                var i = _g2++;
                _g.push(0);
            }
            this.tensionReels = _g;
            this.initPaylines();
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.initPaylines = function() {
            this.paylines = [];
            var _g = 0;
            var _g1 = this.slotDefinition.lines;
            while (_g < _g1.length) {
                var line = _g1[_g];
                ++_g;
                this.paylines.push(line.offsets);
            }
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setGameConfig = function(config) {
            this.config = config;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setSpinOutcome = function(spinOutcome) {
            this.spinOutcome = spinOutcome;
            if (this.spinOutcome.stage == "BaseGame") this.setOutcome(this.spinOutcome.baseGame.outcome);
            else this.setOutcome(this.spinOutcome.freeSpin.outcome);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setOutcome = function(outcome) {
            console.log("[GAME_CONTROLLER] setOutcome -> ");
            this.outcome = outcome;
            this.sortWinLines(outcome);
            this.multiplier = 1;
            if (outcome.customField != null) this.multiplier = outcome.customField.multiplier;
            this.collectTensions();
            this.addTriggerShowAllLinesDuringWinPresentation();
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.sortWinLines = function(outcome) {
            if (outcome == null || outcome.lineWins == null || outcome.lineWins.length == 0) return;
            outcome.lineWins.sort(function(a, b) {
                if (parseFloat(a.payout) < parseFloat(b.payout)) return 1;
                else if (parseFloat(a.payout) > parseFloat(b.payout)) return -1;
                return 0;
            });
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.collectTensions = function() {
            if (this.isTensionsRequired()) this.tensionReels[2] = 1;
            else this.tensionReels[2] = 0;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isTensionsRequired = function() {
            return this.isBonusTensionRequired() || this.isWildTensionRequired();
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isBonusTensionRequired = function() {
            return !this.isAlreadyMaxFreeSpins() && this.hasBonusSymbolOnTheReel(0) && this.hasBonusSymbolOnTheReel(1);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isWildTensionRequired = function() {
            return this.symbolsOnAPayline(this.wildSymbolId, 2);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isActiveWildOnReel = function(reelId) {
            var posOfWildOnReel = this.getSymbolIndexOnTheReel(this.wildSymbolId, reelId);
            if (posOfWildOnReel < 0) return false;
            return _hcmn_.Lambda.exists(this.activePaylines, function(line) {
                return line[reelId] == posOfWildOnReel + tripleRedHotSevensIXFGameController.GameModel.REEL_POSITION_VS_LINE_OFFSET;
            });
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isAlreadyMaxFreeSpins = function() {
            if (!this.hasFreeSpinOutcome()) return false;
            var freeSpins = this.spinOutcome.freeSpin;
            return freeSpins.isMaxAwarded && freeSpins.awarded == 0;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.addTriggerShowAllLinesDuringWinPresentation = function() {
            if (this.outcome.lineWins != null && _hcmn_.HxOverrides.indexOf(this.outcome.lineWins, this.winLineAsTriggerForShowingAllLines, 0) == -1) this.outcome.lineWins.unshift(this.winLineAsTriggerForShowingAllLines);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setCurrentStake = function(stakeState) {
            this.stakeState = stakeState;
            this.activePaylines = this.paylines.slice(0, stakeState.stakeItems.lineCount);
            this.totalBet = stakeState.totalBet;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setAbortSpinPayload = function(asp) {
            this.abortSpinPayload = asp;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.setStartSpinPayload = function(ssp) {
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var i = _g1++;
                if (ssp[i] == null) ssp[i] = 0;
                else ssp[i] = ssp[i];
            }
            this.startSpinPayload = ssp;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getLinePictureForWin = function(win) {
            var result;
            var _g = [];
            var _g2 = 0;
            var _g1 = this.reelsNum;
            while (_g2 < _g1) {
                var i = _g2++;
                _g.push("-");
            }
            result = _g;
            var reelsInfo = win.winPath.reelsInfo;
            var reels = this.outcome.reelStop.reels;
            var _g21 = 0;
            var _g11 = win.symbolCount;
            while (_g21 < _g11) {
                var k = _g21++;
                var _g4 = 0;
                var _g3 = reelsInfo[k].length;
                while (_g4 < _g3) {
                    var i1 = _g4++;
                    if (win.winPath.reelsInfo[k][i1] == 1) {
                        result[k] = reels[k][i1];
                        break;
                    }
                }
            }
            if (win.type == "LineRight") result.reverse();
            return result;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.hasWinInOutcome = function() {
            var hasWinLines = this.outcome.lineWins != null && this.outcome.lineWins.length > 0;
            var hasBonusSymbols = this.outcome.bonusWins != null && this.outcome.bonusWins.length > 0;
            var hasScatters = this.outcome.scatterWins != null && this.outcome.scatterWins.length > 0;
            return hasWinLines || hasBonusSymbols || hasScatters;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.hasBonusPayout = function() {
            return this.getBonusPayout().isNotZero();
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getBonusPayout = function() {
            return this.moneyValueProvider.provide(this.spinOutcome.freeSpin.outcome.totalPayout);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getDelayForExecuteContinueCommand = function() {
            if (this.isResume) return this.config.fs_FirstSpinDelay;
            if (this.spinOutcome.stage == "FreeSpin") {
                if (this.hasBonusPayout() && this.abortSpinPayload == null) return 0;
                else return this.config.fs_NoWinSpinDelay;
            } else return this.config.fs_FirstSpinDelay;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getEmptyMatrix = function(defaultValue) {
            var visibility;
            var _g = [];
            var _g2 = 0;
            var _g1 = this.reelsNum;
            while (_g2 < _g1) {
                var i = _g2++;
                _g.push((function($this) {
                    var $r;
                    var _g3 = []; {
                        var _g5 = 0;
                        var _g4 = $this.cellsNum;
                        while (_g5 < _g4) {
                            var j = _g5++;
                            _g3.push(defaultValue);
                        }
                    }
                    $r = _g3;
                    return $r;
                }(this)));
            }
            visibility = _g;
            return visibility;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getCurrentFreeSpin = function() {
            return this.formatCounter(this.getCurrentFreeSpinNumber(), this.getTotalFreeSpins());
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getNextFreeSpin = function() {
            return this.formatCounter(this.getCurrentFreeSpinNumber() + 1, this.getTotalFreeSpins());
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getCurrentFreeSpinNumber = function() {
            if (this.hasFreeSpinOutcome()) return this.spinOutcome.freeSpin.current;
            else return 0;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getTotalFreeSpins = function() {
            if (this.hasFreeSpinOutcome()) return this.spinOutcome.freeSpin.total;
            else return 0;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.hasFreeSpinOutcome = function() {
            return this.spinOutcome != null && this.spinOutcome.freeSpin != null;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.formatCounter = function(current, total) {
            return "" + current + "/" + total;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getFreeSpinsTotalWin = function(zeroValue) {
            if (zeroValue == null) zeroValue = "";
            var totalWin = this.spinOutcome.acumulatedFreeSpinPayout;
            if (totalWin == "0") return zeroValue;
            else return this.moneyValueProvider.provide(totalWin).format(2);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.hasBonusSymbolOnTheReel = function(reel, inWinableZone) {
            if (inWinableZone == null) inWinableZone = true;
            return this.hasSymbolOnTheReel(this.bonusSymbolId, reel, inWinableZone);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.hasSymbolOnTheReel = function(symbolId, reel, inWinableZone) {
            if (inWinableZone == null) inWinableZone = true;
            return this.getSymbolIndexOnTheReel(symbolId, reel, inWinableZone) >= 0;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getBonusSymbolIndexOnTheReel = function(reel, inWinableZone) {
            if (inWinableZone == null) inWinableZone = true;
            return this.getSymbolIndexOnTheReel(this.bonusSymbolId, reel, inWinableZone);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getSymbolIndexOnTheReel = function(symbolId, reelId, inWinableZone) {
            if (inWinableZone == null) inWinableZone = true;
            var reel = this.outcome.reelStop.reels[reelId];
            if (inWinableZone) reel = reel.slice(1, reel.length - 1);
            return _hcmn_.HxOverrides.indexOf(reel, symbolId, 0);
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.symbolsOnAPayline = function(symbolId, symbolCount) {
            var _g = this;
            var offsets = [];
            var _g1 = 0;
            while (_g1 < symbolCount) {
                var i = _g1++;
                var posOnReel = this.getSymbolIndexOnTheReel(symbolId, i);
                if (posOnReel < 0) return false;
                offsets.push(posOnReel + tripleRedHotSevensIXFGameController.GameModel.REEL_POSITION_VS_LINE_OFFSET);
            }
            return _hcmn_.Lambda.exists(this.activePaylines, function(line) {
                return _g.matchLine(offsets, line);
            });
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.matchLine = function(offsets, line) {
            var _g1 = 0;
            var _g = offsets.length;
            while (_g1 < _g) {
                var i = _g1++;
                if (offsets[i] != line[i]) return false;
            }
            return true;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getBetPanelTopicForNewStakeItems = function(stakeItems) {
            if (this.stakeState == null) return tripleRedHotSevensIXFGameController.GameModel.BET_UNDEF_TOPIC;
            var newBet = parseFloat(stakeItems.betPerLine);
            var prevBet = parseFloat(this.stakeState.stakeItems.betPerLine);
            var prevLines = this.stakeState.stakeItems.lineCount;
            if (newBet != prevBet) return this.betPerLineChangeDirection(prevBet, newBet);
            else if (stakeItems.lineCount != prevLines) return this.numberOfLinesChangeDirection(prevLines, stakeItems.lineCount);
            else return tripleRedHotSevensIXFGameController.GameModel.BET_UNDEF_TOPIC;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.betPerLineChangeDirection = function(prevBet, newBet) {
            if (newBet > prevBet)
                if (this.isMaxBetPerLine(newBet)) return tripleRedHotSevensIXFGameController.GameModel.BET_MAX_TOPIC;
                else return tripleRedHotSevensIXFGameController.GameModel.BET_UP_TOPIC;
            return tripleRedHotSevensIXFGameController.GameModel.BET_DOWN_TOPIC;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.numberOfLinesChangeDirection = function(prevLines, newLines) {
            if (newLines > prevLines) return tripleRedHotSevensIXFGameController.GameModel.BET_UP_TOPIC;
            return tripleRedHotSevensIXFGameController.GameModel.BET_DOWN_TOPIC;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isMaxBetPerLine = function(bet) {
            var lastBet = _hcmn_.Std.parseFloat(this.getLastValue(this.stakeState.totalBetsForSelectedLines));
            return bet == lastBet;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.getLastValue = function(arr) {
            var lastPair = arr[arr.length - 1];
            return lastPair.value;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.isHighWin = function() {
            if (this.spinOutcome != null) {
                var totalPayout = parseFloat(this.spinOutcome.baseGame.outcome.totalPayout);
                if (this.spinOutcome.stage == "FreeSpin" && this.spinOutcome.nextStage == "BaseGame" && this.isBonusSummary && !this.isFSOutroPopup) totalPayout = parseFloat(this.spinOutcome.acumulatedPayout);
                else if (this.spinOutcome.stage == "FreeSpin" && this.spinOutcome.nextStage == "BaseGame" && this.isBonusSummary && this.isFSOutroPopup) totalPayout = parseFloat(this.spinOutcome.acumulatedFreeSpinPayout);
                else if (this.spinOutcome.stage == "FreeSpin" && this.spinOutcome.nextStage == "BaseGame" && !this.isBonusSummary && !this.isFSOutroPopup) totalPayout = parseFloat(this.spinOutcome.freeSpin.outcome.totalPayout);
                else if (this.spinOutcome.stage == "FreeSpin" && this.spinOutcome.nextStage == "FreeSpin") totalPayout = parseFloat(this.spinOutcome.freeSpin.outcome.totalPayout);
                var totalBetValue = parseFloat(this.totalBet);
                if (totalPayout > totalBetValue) return true;
                return false;
            } else return true;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.parsePayLines = function(response) {
            var payLines = new _hcmn_.haxe_ds_StringMap();
            var patterns = tripleRedHotSevensIXFGameController.HelpingHand.getArrayField(response, "PatternInfo");
            var _g = 0;
            while (_g < patterns.length) {
                var pattern = patterns[_g];
                ++_g;
                var isPayline = tripleRedHotSevensIXFGameController.HelpingHand.getField(pattern, "@name");
                if (isPayline == "Paylines") {
                    var lines = tripleRedHotSevensIXFGameController.HelpingHand.getArrayField(pattern, "Pattern");
                    var _g1 = 0;
                    while (_g1 < lines.length) {
                        var line = lines[_g1];
                        ++_g1;
                        var lineId = tripleRedHotSevensIXFGameController.HelpingHand.getField(line, "@name").split("Line ")[1];
                        var cells = tripleRedHotSevensIXFGameController.HelpingHand.getArrayField(line, "Cell");
                        var linePositions = [];
                        var position = null;
                        var _g2 = 0;
                        while (_g2 < cells.length) {
                            var cell = cells[_g2];
                            ++_g2;
                            var name = tripleRedHotSevensIXFGameController.HelpingHand.getField(cell, "@name");
                            position = this.parsePosition(name);
                            linePositions.push(position);
                        }
                        payLines.set("bg_" + lineId, linePositions);
                    }
                }
            }
            return payLines;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.parsePosition = function(name) {
            var pos = {
                x: _hcmn_.Std.parseInt(name.split("C")[1].split("R")[0]),
                y: _hcmn_.Std.parseInt(name.split("R")[1])
            };
            return pos;
        };
        tripleRedHotSevensIXFGameController.GameModel.prototype.__class__ = tripleRedHotSevensIXFGameController.GameModel;
        tripleRedHotSevensIXFGameController.StateMachineContext = function(dispatcher) {
            stateMachineEngine.SMContext.call(this, dispatcher);
        };
        tripleRedHotSevensIXFGameController.StateMachineContext.__name__ = ["tripleRedHotSevensIXFGameController", "StateMachineContext"];
        tripleRedHotSevensIXFGameController.StateMachineContext.__super__ = stateMachineEngine.SMContext;
        for (var k in stateMachineEngine.SMContext.prototype) tripleRedHotSevensIXFGameController.StateMachineContext.prototype[k] = stateMachineEngine.SMContext.prototype[k];
        tripleRedHotSevensIXFGameController.StateMachineContext.prototype.setupContextData = function(game) {
            this.set_contextValues(new _hcmn_.haxe_ds_StringMap());
            var this1 = this.get_contextValues();
            this1.set("Stage", "");
            var this2 = this.get_contextValues();
            this2.set("retrigger", false);
            var this3 = this.get_contextValues();
            this3.set("NextStage", "");
            var this4 = this.get_contextValues();
            this4.set("awardCapExceeded", false);
            this.set_contextMethods(new _hcmn_.haxe_ds_StringMap());
            var this5 = this.get_contextMethods();
            this5.set("attachComponents", $bind(game, game.attachComponents));
            var this6 = this.get_contextMethods();
            this6.set("initGame", $bind(game, game.initGame));
            var this7 = this.get_contextMethods();
            this7.set("prepareResume", $bind(game, game.prepareResume));
            var this8 = this.get_contextMethods();
            this8.set("onBaseGameIdle", $bind(game, game.onBaseGameIdle));
            var this9 = this.get_contextMethods();
            this9.set("startSpin", $bind(game, game.startSpin));
            var this10 = this.get_contextMethods();
            this10.set("clearAllWins", $bind(game, game.clearAllWins));
            var this11 = this.get_contextMethods();
            this11.set("checkForStopOrAbort", $bind(game, game.checkForStopOrAbort));
            var this12 = this.get_contextMethods();
            this12.set("applyAbortData", $bind(game, game.applyAbortData));
            var this13 = this.get_contextMethods();
            this13.set("stopReels", $bind(game, game.stopReels));
            var this14 = this.get_contextMethods();
            this14.set("showBaseGameOutcome", $bind(game, game.showBaseGameOutcome));
            var this15 = this.get_contextMethods();
            this15.set("prepareAwardCap", $bind(game, game.prepareAwardCap));
            var this16 = this.get_contextMethods();
            this16.set("showAwardCapScreen", $bind(game, game.showAwardCapScreen));
            var this17 = this.get_contextMethods();
            this17.set("publishResultPresented", $bind(game, game.publishResultPresented));
            var this18 = this.get_contextMethods();
            this18.set("showScatterWins", $bind(game, game.showScatterWins));
            var this19 = this.get_contextMethods();
            this19.set("startFSIntroAnim", $bind(game, game.startFSIntroAnim));
            var this20 = this.get_contextMethods();
            this20.set("prepareFreeSpin", $bind(game, game.prepareFreeSpin));
            var this21 = this.get_contextMethods();
            this21.set("publishSpinOutcomePresented", $bind(game, game.publishSpinOutcomePresented));
            var this22 = this.get_contextMethods();
            this22.set("executeContinueCommand", $bind(game, game.executeContinueCommand));
            var this23 = this.get_contextMethods();
            this23.set("updateFreeSpinsBetPanel", $bind(game, game.updateFreeSpinsBetPanel));
            var this24 = this.get_contextMethods();
            this24.set("showFreeSpinOutcome", $bind(game, game.showFreeSpinOutcome));
            var this25 = this.get_contextMethods();
            this25.set("showRetriggerScreen", $bind(game, game.showRetriggerScreen));
            var this26 = this.get_contextMethods();
            this26.set("startFSOutroAnim", $bind(game, game.startFSOutroAnim));
            var this27 = this.get_contextMethods();
            this27.set("setBaseGameOutcome", $bind(game, game.setBaseGameOutcome));
            var this28 = this.get_contextMethods();
            this28.set("showFreeSpinSummary", $bind(game, game.showFreeSpinSummary));
        };
        tripleRedHotSevensIXFGameController.StateMachineContext.prototype.isFreeSpin = function() {
            return (function($this) {
                var $r;
                var this1 = $this.get_contextValues();
                $r = this1.get("Stage");
                return $r;
            }(this)) == "FreeSpin";
        };
        tripleRedHotSevensIXFGameController.StateMachineContext.prototype.isNextFreeSpin = function() {
            return (function($this) {
                var $r;
                var this1 = $this.get_contextValues();
                $r = this1.get("NextStage");
                return $r;
            }(this)) == "FreeSpin";
        };
        tripleRedHotSevensIXFGameController.StateMachineContext.prototype.__class__ = tripleRedHotSevensIXFGameController.StateMachineContext;
        tripleRedHotSevensIXFGameController.StateMachineDef = function() {};
        tripleRedHotSevensIXFGameController.StateMachineDef.__name__ = ["tripleRedHotSevensIXFGameController", "StateMachineDef"];
        tripleRedHotSevensIXFGameController.StateMachineDef.prototype.__class__ = tripleRedHotSevensIXFGameController.StateMachineDef;
        tripleRedHotSevensIXFGameController.StopReelsCondition = {
            __ename__: ["tripleRedHotSevensIXFGameController", "StopReelsCondition"],
            __constructs__: ["STOP_RECEIVED", "SPINNING_STARTED", "MULTIPLIER_FINISHED"]
        };
        tripleRedHotSevensIXFGameController.StopReelsCondition.MULTIPLIER_FINISHED = ["MULTIPLIER_FINISHED", 2];
        tripleRedHotSevensIXFGameController.StopReelsCondition.MULTIPLIER_FINISHED.toString = $estr;
        tripleRedHotSevensIXFGameController.StopReelsCondition.MULTIPLIER_FINISHED.__enum__ = tripleRedHotSevensIXFGameController.StopReelsCondition;
        tripleRedHotSevensIXFGameController.StopReelsCondition.STOP_RECEIVED = ["STOP_RECEIVED", 0];
        tripleRedHotSevensIXFGameController.StopReelsCondition.STOP_RECEIVED.toString = $estr;
        tripleRedHotSevensIXFGameController.StopReelsCondition.STOP_RECEIVED.__enum__ = tripleRedHotSevensIXFGameController.StopReelsCondition;
        tripleRedHotSevensIXFGameController.StopReelsCondition.SPINNING_STARTED = ["SPINNING_STARTED", 1];
        tripleRedHotSevensIXFGameController.StopReelsCondition.SPINNING_STARTED.toString = $estr;
        tripleRedHotSevensIXFGameController.StopReelsCondition.SPINNING_STARTED.__enum__ = tripleRedHotSevensIXFGameController.StopReelsCondition;
        tripleRedHotSevensIXFGameController.AutoplayController = function(betPanel, slotmodelPort) {
            this.lastSpin = false;
            this.active = false;
            this.betPanelControl = betPanel;
            this.slotModelPort = slotmodelPort;
            slotmodelPort.getStages().getIdleStage().getAutoSpinStarted().subscribe($bind(this, this.onAutospinStarted));
            slotmodelPort.getStages().getIdleStage().getAutoSpinsStopped().subscribe($bind(this, this.onAutospinStopped));
            slotmodelPort.getGameCommands().getStartAutoSpinsCommandAvailable().subscribe($bind(this, this.onStartAvailable));
            slotmodelPort.getGameCommands().getStopAutoSpinsCommandAvailable().subscribe($bind(this, this.onStopAvailable));
        };
        tripleRedHotSevensIXFGameController.AutoplayController.__name__ = ["tripleRedHotSevensIXFGameController", "AutoplayController"];
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.active = null;
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.lastSpin = null;
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.betPanelControl = null;
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.slotModelPort = null;
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.isActive = function() {
            return this.active;
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.isActiveNotLast = function() {
            return this.active && !this.lastSpin;
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.start = function() {
            this.slotModelPort.getGameCommands().getStartAutoSpinsCommandExecuted().publish(new slotModelApi.AutospinCommandPayload());
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.stop = function() {
            if (!this.active) return;
            this.active = false;
            this.slotModelPort.getGameCommands().getStopAutoSpinsCommandExecuted().publish(null);
            this.betPanelControl.disableButton(betPanelApi.EButton.AUTO_PLAY_BUTTON);
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.onStopAvailable = function(e) {
            if (e.getPayload()) this.betPanelControl.setAutoPlayButtonState(betPanelApi.SetAutoPlayButtonState.STOP_BUTTON_STATE);
            this.betPanelControl.enableButton(betPanelApi.EButton.AUTO_PLAY_BUTTON, e.getPayload());
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.onStartAvailable = function(e) {
            if (e.getPayload()) this.betPanelControl.setAutoPlayButtonState(betPanelApi.SetAutoPlayButtonState.PLAY_BUTTON_STATE);
            this.betPanelControl.enableButton(betPanelApi.EButton.AUTO_PLAY_BUTTON, e.getPayload());
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.onAutospinStopped = function(e) {
            this.active = false;
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.onAutospinStarted = function(e) {
            this.active = true;
            var payload = e.getPayload();
            this.lastSpin = payload.current == payload.total;
            this.betPanelControl.setNumberOffAutoSpinsLeft(payload.current + " / " + payload.total);
        };
        tripleRedHotSevensIXFGameController.AutoplayController.prototype.__class__ = tripleRedHotSevensIXFGameController.AutoplayController;
        tripleRedHotSevensIXFGameController.SkipController = function(betPanelControl) {
            this.betPanelControl = betPanelControl;
        };
        tripleRedHotSevensIXFGameController.SkipController.__name__ = ["tripleRedHotSevensIXFGameController", "SkipController"];
        tripleRedHotSevensIXFGameController.SkipController.prototype.betPanelControl = null;
        tripleRedHotSevensIXFGameController.SkipController.prototype.skipBtnSubscription = null;
        tripleRedHotSevensIXFGameController.SkipController.prototype.resolveFn = null;
        tripleRedHotSevensIXFGameController.SkipController.prototype.onButtonPressed = function(e) {
            if (this.resolveFn != null) {
                this.resolveFn(null);
                this.resolveFn = null;
            }
        };
        tripleRedHotSevensIXFGameController.SkipController.prototype.show = function() {
            var _g = this;
            var p = new Promise(function(resolve, reject) {
                _g.resolveFn = resolve;
                _g.skipBtnSubscription = _g.betPanelControl.onButtonPressed($bind(_g, _g.onButtonPressed), betPanelApi.EButton.SKIP);
                _g.betPanelControl.showSkipButton();
            });
            return p;
        };
        tripleRedHotSevensIXFGameController.SkipController.prototype.hide = function(enableSpin) {
            if (enableSpin == null) enableSpin = false;
            this.betPanelControl.showSpinButton(enableSpin);
            this.skipBtnSubscription.unsubscribe();
        };
        tripleRedHotSevensIXFGameController.SkipController.prototype.__class__ = tripleRedHotSevensIXFGameController.SkipController;
        tripleRedHotSevensIXFGameController.TopicToRequest = function(winMetterControl) {
            this.winMetterControl = winMetterControl;
        };
        tripleRedHotSevensIXFGameController.TopicToRequest.__name__ = ["tripleRedHotSevensIXFGameController", "TopicToRequest"];
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.winMetterControl = null;
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.onDisplayWinFinished = null;
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.resolve = null;
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.beforeResolve = null;
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.onBeforeResolve = function(callback) {
            this.beforeResolve = callback;
            return this;
        };
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.execute = function(payload) {
            var _g = this;
            var p = new Promise(function(resolve, reject) {
                _g.resolve = resolve;
                _g.onDisplayWinFinished = _g.winMetterControl.onDisplayWinFinished($bind(_g, _g.onResponse));
                _g.winMetterControl.displayWin(payload.winAmount, payload.winSegments, payload.instantShow, payload.startingAmount);
            });
            return p;
        };
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.onResponse = function(e) {
            var payload = e.getPayload();
            this.onDisplayWinFinished.unsubscribe();
            if (this.beforeResolve != null) this.beforeResolve(payload);
            this.resolve(payload);
            this.resolve = null;
        };
        tripleRedHotSevensIXFGameController.TopicToRequest.prototype.__class__ = tripleRedHotSevensIXFGameController.TopicToRequest;
        tripleRedHotSevensIXFGameController.WinMeterController = function(winMeterControl) {
            this.winMeterControl = winMeterControl;
        };
        tripleRedHotSevensIXFGameController.WinMeterController.__name__ = ["tripleRedHotSevensIXFGameController", "WinMeterController"];
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.winMeterControl = null;
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.payload = null;
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.showWin = function(payload) {
            this.payload = payload;
            var request = new tripleRedHotSevensIXFGameController.TopicToRequest(this.winMeterControl);
            return request.execute(payload);
        };
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.show = function(winAmount, bigWin, isHighWin) {
            tripleRedHotSevensIXFGameController.ExternalService.busChanel.publish("winMeterCountupGroup" + bigWin.winGroup, null);
            var instant = false;
            if (!isHighWin) instant = true;
            var payload = new winMeterApi.WinMeterPayload(winAmount, bigWin.winSegments, instant);
            return this.showWin(payload);
        };
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.showImmediately = function(winAmount) {
            var payload = new winMeterApi.WinMeterPayload(winAmount, [], true);
            return this.showWin(payload);
        };
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.stop = function() {
            if (this.payload == null) return;
            this.winMeterControl.displayWin(this.payload.winAmount, this.payload.winSegments, true);
        };
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.clear = function() {
            this.payload = null;
            this.winMeterControl.clear();
        };
        tripleRedHotSevensIXFGameController.WinMeterController.prototype.__class__ = tripleRedHotSevensIXFGameController.WinMeterController;
        tripleRedHotSevensIXFGameController.Data = function() {};
        tripleRedHotSevensIXFGameController.Data.__name__ = ["tripleRedHotSevensIXFGameController", "Data"];
        tripleRedHotSevensIXFGameController.Data.prototype.__class__ = tripleRedHotSevensIXFGameController.Data;
        tripleRedHotSevensIXFGameController.HelpingHand = function() {};
        tripleRedHotSevensIXFGameController.HelpingHand.__name__ = ["tripleRedHotSevensIXFGameController", "HelpingHand"];
        tripleRedHotSevensIXFGameController.HelpingHand.isEmpty = function(value) {
            if (value == null) return true;
            if (value == "") return true;
            return false;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getArray = function(object) {
            var result = null;
            if (object == null) return null;
            if ((object instanceof Array) && object.__enum__ == null) result = object;
            else if (Object.prototype.hasOwnProperty.call(object, "#text")) result = [_hcmn_.Reflect.field(object, "#text")];
            else result = [object];
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getStringArray = function(object) {
            if (object == null) return null;
            var dynamicResult = null;
            if ((object instanceof Array) && object.__enum__ == null) dynamicResult = object;
            else dynamicResult = [object];
            var result = [];
            var item;
            var _g = 0;
            while (_g < dynamicResult.length) {
                var item1 = dynamicResult[_g];
                ++_g;
                result.push(_hcmn_.Std.string(item1));
            }
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getIntArray = function(object) {
            if (object == null) return null;
            var dynamicResult = null;
            if ((object instanceof Array) && object.__enum__ == null) dynamicResult = object;
            else dynamicResult = [object];
            var result = [];
            var item;
            var _g = 0;
            while (_g < dynamicResult.length) {
                var item1 = dynamicResult[_g];
                ++_g;
                result.push(_hcmn_.js_Boot.__cast(item1, _hcmn_.Int));
            }
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getField = function(object, path) {
            if (object == null) return null;
            var pathArray = path.split(".");
            var fieldName = pathArray.shift();
            var remainingPath = pathArray.join(".");
            var field;
            if (Object.prototype.hasOwnProperty.call(object, fieldName)) {
                field = _hcmn_.Reflect.field(object, fieldName);
                if (pathArray.length == 0) return field;
                else return tripleRedHotSevensIXFGameController.HelpingHand.getField(field, remainingPath);
            }
            return null;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getBoolField = function(object, name, defaultValue) {
            var dynammicValue = tripleRedHotSevensIXFGameController.HelpingHand.getField(object, name);
            if (dynammicValue == null) return defaultValue;
            return _hcmn_.Std.string(dynammicValue).toLowerCase() == "true";
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getArrayField = function(object, name) {
            var field = tripleRedHotSevensIXFGameController.HelpingHand.getField(object, name);
            return tripleRedHotSevensIXFGameController.HelpingHand.getArray(field);
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getIntArrayField = function(object, name) {
            if (object == null) return null;
            var resultDynamicArray = tripleRedHotSevensIXFGameController.HelpingHand.getArrayField(object, name);
            if (resultDynamicArray == null) return null;
            var result = [];
            var resultItem;
            var _g = 0;
            while (_g < resultDynamicArray.length) {
                var resultItem1 = resultDynamicArray[_g];
                ++_g;
                result.push(_hcmn_.js_Boot.__cast(resultItem1, _hcmn_.Int));
            }
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getArrayInJsonString = function(jsonString, namePath, onError) {
            var json;
            try {
                json = JSON.parse(jsonString);
            } catch (exception) {
                if (exception instanceof js._Boot.HaxeError) exception = exception.val;
                if (onError != null) onError(_hcmn_.Std.string(exception));
                return null;
            }
            return tripleRedHotSevensIXFGameController.HelpingHand.getArray(tripleRedHotSevensIXFGameController.HelpingHand.getField(json, namePath));
        };
        tripleRedHotSevensIXFGameController.HelpingHand.getObjectInJsonString = function(jsonString, namePath, onError) {
            var json;
            try {
                json = JSON.parse(jsonString);
            } catch (exception) {
                if (exception instanceof js._Boot.HaxeError) exception = exception.val;
                if (onError != null) onError(_hcmn_.Std.string(exception));
                return null;
            }
            return tripleRedHotSevensIXFGameController.HelpingHand.getField(json, namePath);
        };
        tripleRedHotSevensIXFGameController.HelpingHand.parseInt = function(object, onError) {
            var result = null;
            try {
                result = _hcmn_.Std.parseInt(_hcmn_.Std.string(object));
            } catch (exception) {
                if (exception instanceof js._Boot.HaxeError) exception = exception.val;
                if (onError != null) onError(_hcmn_.Std.string(exception));
                return null;
            }
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.parseIntField = function(object, name, onError) {
            var dynamicValue = tripleRedHotSevensIXFGameController.HelpingHand.getField(object, name);
            if (dynamicValue == null) return null;
            return tripleRedHotSevensIXFGameController.HelpingHand.parseInt(dynamicValue, onError);
        };
        tripleRedHotSevensIXFGameController.HelpingHand.parseIntArrayField = function(object, name, onError) {
            if (object == null) return null;
            var resultDynamicArray = tripleRedHotSevensIXFGameController.HelpingHand.getArrayField(object, name);
            if (resultDynamicArray == null) return null;
            var result = [];
            var resultItem;
            var _g = 0;
            while (_g < resultDynamicArray.length) {
                var resultItem1 = resultDynamicArray[_g];
                ++_g;
                var item = tripleRedHotSevensIXFGameController.HelpingHand.parseInt(resultItem1, onError);
                if (item == null) return null;
                result.push(item);
            }
            return result;
        };
        tripleRedHotSevensIXFGameController.HelpingHand.prototype.__class__ = tripleRedHotSevensIXFGameController.HelpingHand;
        tripleRedHotSevensIXFGameController.OutcomeHelper = function() {};
        tripleRedHotSevensIXFGameController.OutcomeHelper.__name__ = ["tripleRedHotSevensIXFGameController", "OutcomeHelper"];
        tripleRedHotSevensIXFGameController.OutcomeHelper.getAsScattersOutcome = function(outcome) {
            var customField = {
                freeSpinsTriggered: true,
                multiplier: outcome.customField.multiplier
            };
            return new slotModelApi.Outcome(outcome.reelStop, outcome.reelStopAdditional, null, outcome.scatterWins, null, null, null, null, customField);
        };
        tripleRedHotSevensIXFGameController.OutcomeHelper.reduceBigWin = function(bigWin, maxWinGroup) {
            if (maxWinGroup == null) maxWinGroup = 1;
            var segments = bigWin.winSegments;
            var winAmount = segments[segments.length - 1].totalWin;
            var winGroup = _hcmn_.Math.min(bigWin.winGroup, maxWinGroup);
            return new slotModelApi.BigWin(winGroup, [new slotModelApi.BigWinSegment(1, winAmount)], bigWin.customGroups);
        };
        tripleRedHotSevensIXFGameController.OutcomeHelper.getAsFreeSpinSummaryOutcome = function(outcome, freeSpinsTotalWin) {
            var sc = outcome.scatterWins[0];
            var bonusSymbolPayout = new commonTools.DecimalValue(sc.payout).asFloat();
            var freeSpinsPayout = new commonTools.DecimalValue(freeSpinsTotalWin).asFloat();
            var sum = commonTools.FloatUtil.fixedFloat(bonusSymbolPayout + freeSpinsPayout);
            var scatterAndFS = new slotModelApi.ScatterWin(sc.name, sc.price, sc.multiplier, "" + sum, sc.winPath, sc.winningSymbol, sc.symbolCount);
            var customField = {
                freeSpinsTriggered: false,
                multiplier: outcome.customField.multiplier
            };
            return new slotModelApi.Outcome(outcome.reelStop, outcome.reelStopAdditional, outcome.lineWins, [scatterAndFS], outcome.bonusWins, outcome.pickerWins, outcome.totalPayout, outcome.bigWin, customField);
        };
        tripleRedHotSevensIXFGameController.OutcomeHelper.prototype.__class__ = tripleRedHotSevensIXFGameController.OutcomeHelper;
        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"
                };
            }
        };
        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;
        tripleRedHotSevensIXFGameController.GameController.SKIP_TUTORIAL_OPTION = "tutorialConfirmed";;
        tripleRedHotSevensIXFGameController.GameController.STORAGE_PREFIX = "tripleRedHotSevensIXF_";;
        tripleRedHotSevensIXFGameController.GameModel.SPAGHETTI_LINE_WIN = "showWinLines";;
        tripleRedHotSevensIXFGameController.GameModel.BET_UP_TOPIC = "betButtonPressed:nextBet";;
        tripleRedHotSevensIXFGameController.GameModel.BET_DOWN_TOPIC = "betButtonPressed:previousBet";;
        tripleRedHotSevensIXFGameController.GameModel.BET_MAX_TOPIC = "betButtonPressed:maxBet";;
        tripleRedHotSevensIXFGameController.GameModel.BET_UNDEF_TOPIC = "betButtonPressed:undefined";;
        tripleRedHotSevensIXFGameController.GameModel.REEL_POSITION_VS_LINE_OFFSET = 2;;
        tripleRedHotSevensIXFGameController.StateMachineDef.ID = "GAMECONTROLLERSM_";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_INTRO_ENDED = "FS_INTRO_ENDED";;
        tripleRedHotSevensIXFGameController.StateMachineDef.START_REEL_SPIN = "START_REEL_SPIN";;
        tripleRedHotSevensIXFGameController.StateMachineDef.PRESENT_SPIN_OUTCOME = "PRESENT_SPIN_OUTCOME";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTRO_END = "FS_OUTRO_END";;
        tripleRedHotSevensIXFGameController.StateMachineDef.CONTINUE_ENABLED = "CONTINUE_ENABLED";;
        tripleRedHotSevensIXFGameController.StateMachineDef.ABORT_SPIN = "ABORT_SPIN";;
        tripleRedHotSevensIXFGameController.StateMachineDef.SPIN_ENABLED = "SPIN_ENABLED";;
        tripleRedHotSevensIXFGameController.StateMachineDef.PRESENT_RESULT = "PRESENT_RESULT";;
        tripleRedHotSevensIXFGameController.StateMachineDef.INIT_ACTION = "INIT_ACTION";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTCOME_DONE = "FS_OUTCOME_DONE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.STOP_REEL_SPIN = "STOP_REEL_SPIN";;
        tripleRedHotSevensIXFGameController.StateMachineDef.RETRIGGER_SHOWN = "RETRIGGER_SHOWN";;
        tripleRedHotSevensIXFGameController.StateMachineDef.PREPARE_RESUME = "PREPARE_RESUME";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_ENTRY_SHOWN = "FS_ENTRY_SHOWN";;
        tripleRedHotSevensIXFGameController.StateMachineDef.CONTINUE = "CONTINUE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.SPIN_STARTING_ENDED = "SPIN_STARTING_ENDED";;
        tripleRedHotSevensIXFGameController.StateMachineDef.LOADING_STATE = "LOADING_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.PREPARE_RESUME_STATE = "PREPARE_RESUME_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.RESUME_STATE = "RESUME_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.INIT_STATE = "INIT_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.INTRO_STATE = "INTRO_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.IDLE_STATE = "IDLE_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.SPINNING_STATE = "SPINNING_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_IDLE = "FS_IDLE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.ABORT_SPIN_STATE = "ABORT_SPIN_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.STOPPING_STATE = "STOPPING_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.AWARD_CAP_STATE = "AWARD_CAP_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.AWARD_CAP_PREPARE = "AWARD_CAP_PREPARE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_ENTRY = "FS_ENTRY";;
        tripleRedHotSevensIXFGameController.StateMachineDef.BASEGAME_OUTCOME = "BASEGAME_OUTCOME";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTCOME = "FS_OUTCOME";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_INTRO = "FS_INTRO";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTRO = "FS_OUTRO";;
        tripleRedHotSevensIXFGameController.StateMachineDef.RETRIGGER_STATE = "RETRIGGER_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_OUTCOME_PRESENTED = "FS_OUTCOME_PRESENTED";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FS_SUMMARY = "FS_SUMMARY";;
        tripleRedHotSevensIXFGameController.StateMachineDef.BET_CONFIRM = "BET_CONFIRM";;
        tripleRedHotSevensIXFGameController.StateMachineDef.SHOW_WIN_STATE = "SHOW_WIN_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.SPIN_STARTING_STATE = "SPIN_STARTING_STATE";;
        tripleRedHotSevensIXFGameController.StateMachineDef.FSM = "<fsm initial='LOADING_STATE'>\r\n  <state name='LOADING_STATE'>\r\n    <transition target='PREPARE_RESUME_STATE' action='PREPARE_RESUME'/>\r\n    <transition target='INIT_STATE' action='INIT_ACTION'/>\r\n    <operation type='do' method='attachComponents'/>\r\n  </state>\r\n  <state name='PREPARE_RESUME_STATE'>\r\n    <transition target='RESUME_STATE' action='CONTINUE_ENABLED'/>\r\n    <operation type='do' method='prepareResume'/>\r\n  </state>\r\n  <state name='RESUME_STATE'>\r\n    <transition target='FS_IDLE' action='FS_INTRO_ENDED'/>\r\n    <operation type='exit' method='prepareFreeSpin'/>\r\n  </state>\r\n  <state name='INIT_STATE'>\r\n    <transition target='IDLE_STATE' action='SPIN_ENABLED'/>\r\n    <operation type='do' method='initGame'/>\r\n  </state>\r\n  <state name='IDLE_STATE'>\r\n    <transition target='SPIN_STARTING_STATE' action='START_REEL_SPIN'/>\r\n    <operation type='do' method='onBaseGameIdle'/>\r\n  </state>\r\n  <state name='SPIN_STARTING_STATE'>\r\n    <transition target='SPINNING_STATE' action='SPIN_STARTING_ENDED'/>\r\n    <operation type='do' method='clearAllWins'/>\r\n    <operation type='do' method='startSpin'/>\r\n  </state>\r\n  <state name='SPINNING_STATE'>\r\n    <transition target='STOPPING_STATE' action='STOP_REEL_SPIN'/>\r\n    <transition target='ABORT_SPIN_STATE' action='ABORT_SPIN'/>\r\n    <operation type='do' method='checkForStopOrAbort'/>\r\n  </state>\r\n  <state name='FS_IDLE'>\r\n    <transition target='SPIN_STARTING_STATE' action='START_REEL_SPIN'/>\r\n    <operation type='do' method='executeContinueCommand'/>\r\n    <operation type='exit' method='updateFreeSpinsBetPanel'/>\r\n  </state>\r\n  <state name='ABORT_SPIN_STATE'>\r\n    <transition target='IDLE_STATE' action='SPIN_ENABLED'/>\r\n\t<transition target='FS_IDLE' action='CONTINUE_ENABLED'/>\r\n\t<operation type='entry' method='applyAbortData'/>\r\n  </state>\r\n  <state name='STOPPING_STATE'>\r\n    <transition target='FS_ENTRY' condition='!awardCapExceeded,Stage==BaseGame,NextStage==FreeSpin' action='PRESENT_SPIN_OUTCOME'/>\r\n    <transition target='BASEGAME_OUTCOME' condition='!awardCapExceeded,Stage==BaseGame,NextStage==BaseGame' action='PRESENT_SPIN_OUTCOME'/>\r\n    <transition target='FS_OUTCOME' condition='!awardCapExceeded,Stage==FreeSpin' action='PRESENT_SPIN_OUTCOME'/>\r\n    <transition target='AWARD_CAP_PREPARE' condition='awardCapExceeded' action='PRESENT_SPIN_OUTCOME'/>\r\n    <operation type='entry' method='stopReels'/>\r\n  </state>\r\n  <state name='AWARD_CAP_PREPARE'>\r\n    <transition target='AWARD_CAP_STATE' action='PRESENT_RESULT'/>\r\n    <operation type='do' method='prepareAwardCap'/>\r\n  </state>\r\n  <state name='AWARD_CAP_STATE'>\r\n    <transition target='BET_CONFIRM' action='CONTINUE'/>\r\n    <operation type='do' method='showAwardCapScreen'/>\r\n  </state>\r\n  <state name='FS_ENTRY'>\r\n    <transition target='FS_INTRO' action='FS_ENTRY_SHOWN'/>\r\n    <operation type='do' method='showScatterWins'/>\r\n  </state>\r\n  <state name='BASEGAME_OUTCOME'>\r\n    <transition target='BET_CONFIRM' action='PRESENT_RESULT'/>\r\n    <operation type='entry' method='showBaseGameOutcome'/>\r\n  </state>\r\n  <state name='FS_OUTCOME'>\r\n    <transition target='RETRIGGER_STATE' condition='retrigger' action='FS_OUTCOME_DONE'/>\r\n    <transition target='FS_OUTCOME_PRESENTED' condition='!retrigger' action='FS_OUTCOME_DONE'/>\r\n\t<operation type='do' method='showFreeSpinOutcome'/>\r\n  </state>\r\n  <state name='FS_INTRO'>\r\n    <transition target='FS_OUTCOME_PRESENTED' action='FS_INTRO_ENDED'/>\r\n    <operation type='entry' method='startFSIntroAnim'/>\r\n    <operation type='exit' method='prepareFreeSpin'/>\r\n  </state>\r\n  <state name='RETRIGGER_STATE'>\r\n    <transition target='FS_OUTCOME_PRESENTED' action='RETRIGGER_SHOWN'/>\r\n    <operation type='do' method='showRetriggerScreen'/>\r\n  </state>\r\n  <state name='FS_OUTCOME_PRESENTED'>\r\n    <transition target='FS_IDLE' action='CONTINUE_ENABLED'/>\r\n    <transition target='FS_OUTRO' action='PRESENT_RESULT'/>\r\n    <operation type='do' method='publishSpinOutcomePresented'/>\r\n  </state>\r\n  <state name='FS_OUTRO'>\r\n    <transition target='FS_SUMMARY' action='FS_OUTRO_END'/>\r\n    <operation type='do' method='startFSOutroAnim'/>\r\n  </state>\r\n  <state name='FS_SUMMARY'>\r\n    <transition target='BET_CONFIRM' action='CONTINUE'/>\r\n    <operation type='entry' method='setBaseGameOutcome'/>\r\n    <operation type='do' method='showFreeSpinSummary'/>\r\n  </state>\r\n  <state name='BET_CONFIRM'>\r\n    <transition target='IDLE_STATE' action='SPIN_ENABLED'/>\r\n\t<transition target='SPIN_STARTING_STATE' action='START_REEL_SPIN'/>\r\n    <operation type='do' method='publishResultPresented'/>\r\n  </state>\r\n</fsm>";;
        tripleRedHotSevensIXFGameController.Data.PatternInfo = {
            'PatternInfo': {
                '@name': "Paylines",
                'Pattern': [{
                    '@name': "Line 1",
                    'Cell': [{
                        '@name': "L0C0R2"
                    }, {
                        '@name': "L0C1R2"
                    }, {
                        '@name': "L0C2R2"
                    }]
                }, {
                    '@name': "Line 2",
                    'Cell': [{
                        '@name': "L0C0R1"
                    }, {
                        '@name': "L0C1R1"
                    }, {
                        '@name': "L0C2R1"
                    }]
                }, {
                    '@name': "Line 3",
                    'Cell': [{
                        '@name': "L0C0R3"
                    }, {
                        '@name': "L0C1R3"
                    }, {
                        '@name': "L0C2R3"
                    }]
                }, {
                    '@name': "Line 4",
                    'Cell': [{
                        '@name': "L0C0R1"
                    }, {
                        '@name': "L0C1R2"
                    }, {
                        '@name': "L0C2R3"
                    }]
                }, {
                    '@name': "Line 5",
                    'Cell': [{
                        '@name': "L0C0R3"
                    }, {
                        '@name': "L0C1R2"
                    }, {
                        '@name': "L0C2R1"
                    }]
                }]
            }
        };;
        return {
            exports: tripleRedHotSevensIXFGameController,
            activator: tripleRedHotSevensIXFGameController.Activator
        };
    });