define("slotmodelGamePluginCommonMpt", ["slotModelApi", "money", "clientkernelModulesApi", "slotmodelGamePluginApi", "clientkernelLoggerApi"],
    function(slotModelApi, money, clientkernelModulesApi, slotmodelGamePluginApi, clientkernelLoggerApi) {
        "use strict";

        function $iterator(o) {
            if (o instanceof Array) return function() {
                return {
                    cur: 0,
                    arr: o,
                    hasNext: function() {
                        return this.cur < this.arr.length;
                    },
                    next: function() {
                        return this.arr[this.cur++];
                    }
                };
            };
            return typeof(o.iterator) == 'function' ? $bind(o, o.iterator) : o.iterator;
        };;
        var $fid = 0;

        function $bind(o, m) {
            if (m == null) return null;
            if (m.__id__ == null) m.__id__ = $fid++;
            var f;
            if (o.hx__closures__ == null) o.hx__closures__ = {};
            else f = o.hx__closures__[m.__id__];
            if (f == null) {
                f = function() {
                    return f.method.apply(f.scope, arguments);
                };
                f.scope = o;
                f.method = m;
                o.hx__closures__[m.__id__] = f;
            }
            return f;
        };
        var $_;
        var $estr = function() {
            return _hcmn_.js_Boot.__string_rec(this, '');
        };
        if (typeof haxe == 'undefined') {
            var haxe = {};
        };

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

        };
        if (typeof js == 'undefined') {
            var js = {};
        };
        if (!js._Boot) {
            js._Boot = {};
        };
        js._Boot.HaxeError = function(val) {
            Error.call(this);
            this.val = val;
            this.message = String(val);
            if (Error.captureStackTrace) Error.captureStackTrace(this, js._Boot.HaxeError);
        };
        js._Boot.HaxeError.__name__ = ["js", "_Boot", "HaxeError"];
        js._Boot.HaxeError.__super__ = Error;
        for (var k in Error.prototype) js._Boot.HaxeError.prototype[k] = Error.prototype[k];
        js._Boot.HaxeError.prototype.val = null;
        js._Boot.HaxeError.prototype.__class__ = js._Boot.HaxeError;
        if (typeof slotmodelGamePluginCommonMpt == 'undefined') {
            var slotmodelGamePluginCommonMpt = {};
        };
        slotmodelGamePluginCommonMpt.Common = function() {};
        slotmodelGamePluginCommonMpt.Common.__name__ = ["slotmodelGamePluginCommonMpt", "Common"];
        slotmodelGamePluginCommonMpt.Common.prototype.__class__ = slotmodelGamePluginCommonMpt.Common;
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser = function(gameId, onError, payloadErrorId) {
            this.parseError = false;
            this.gameId = gameId;
            this.onError = onError;
            this.payloadErrorId = payloadErrorId;
            slotmodelGamePluginCommonMpt.MptHelper.init(gameId, onError, payloadErrorId);
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.__name__ = ["slotmodelGamePluginCommonMpt", "PfPluginCommonResponseParser"];
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.gameId = null;
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.onError = null;
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.payloadErrorId = null;
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.parseError = null;
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.onParseFatalError = function(message) {
            slotmodelGamePluginCommonMpt.Log.getLoggerBykey("PFResponseParser").error("[ParseFatalError]" + message);
            this.parseError = true;
            this.onError(this.getFatalError("ParseFatalError", message));
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.getFatalError = function(source, message) {
            return new slotModelApi.Error(this.payloadErrorId, true, "[" + this.gameId + "][" + source + "] " + message);
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.parseKeyValuePairNextSpinStripeLayers = function(paytableResponse, stage) {
            var populationField = stage + ".Section";
            var keyValuesPairInfo = slotmodelGamePluginCommonMpt.StdHelper.getArrayField(paytableResponse, "KeyValuePairInfo");
            if (keyValuesPairInfo == null) return null;
            var mapping = null;
            var _g = 0;
            while (_g < keyValuesPairInfo.length) {
                var keyValuePairInfo = keyValuesPairInfo[_g];
                ++_g;
                var name = slotmodelGamePluginCommonMpt.StdHelper.getField(keyValuePairInfo, "@name");
                if (name == populationField) {
                    mapping = slotmodelGamePluginCommonMpt.StdHelper.getArrayField(keyValuePairInfo, "Mapping");
                    break;
                }
            }
            if (mapping == null) return null;
            var result = new _hcmn_.haxe_ds_StringMap();
            var _g1 = 0;
            while (_g1 < mapping.length) {
                var map = mapping[_g1];
                ++_g1;
                var key = slotmodelGamePluginCommonMpt.StdHelper.getField(map, "@key");
                var value = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(map, "@value", $bind(this, this.onParseFatalError));
                if (_hcmn_.__map_reserved[key] != null) result.setReserved(key, value);
                else result.h[key] = value;
            }
            return result;
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.parseBetPerLineCredit = function(response) {
            var betPerPatternObject = slotmodelGamePluginCommonMpt.StdHelper.getField(response, "PatternSliderInput.BetPerPattern");
            if (betPerPatternObject == null) return null;
            return slotmodelGamePluginCommonMpt.StdHelper.parseInt(betPerPatternObject, $bind(this, this.onParseFatalError));
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.parseSelectedLineCount = function(response) {
            var patternsBetObject = slotmodelGamePluginCommonMpt.StdHelper.getField(response, "PatternSliderInput.PatternsBet");
            if (patternsBetObject == null) return null;
            return slotmodelGamePluginCommonMpt.StdHelper.parseInt(patternsBetObject, $bind(this, this.onParseFatalError));
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.parseTotalWinCredit = function(response) {
            var totalWinObject = slotmodelGamePluginCommonMpt.StdHelper.getField(response, "OutcomeDetail.Payout");
            if (totalWinObject == null) return null;
            return slotmodelGamePluginCommonMpt.StdHelper.parseInt(totalWinObject, $bind(this, this.onParseFatalError));
        };
        slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser.prototype.__class__ = slotmodelGamePluginCommonMpt.PfPluginCommonResponseParser;
        slotmodelGamePluginCommonMpt.Log = function() {};
        slotmodelGamePluginCommonMpt.Log.__name__ = ["slotmodelGamePluginCommonMpt", "Log"];
        slotmodelGamePluginCommonMpt.Log.logerFactory = null;
        slotmodelGamePluginCommonMpt.Log.init = function(context) {
            slotmodelGamePluginCommonMpt.Log.logerFactory = slotmodelGamePluginCommonMpt.Log.getLogerFactory(context);
        };
        slotmodelGamePluginCommonMpt.Log.getLogger = function(object) {
            var key = _hcmn_.Type.getClassName(_hcmn_.Type.getClass(object));
            if (key != null) {
                var keyArray = key.split(".");
                key = keyArray[keyArray.length - 1];
            }
            return slotmodelGamePluginCommonMpt.Log.getLoggerBykey(key);
        };
        slotmodelGamePluginCommonMpt.Log.getLoggerBykey = function(key) {
            if (slotmodelGamePluginCommonMpt.Log.logerFactory == null) return null;
            if (!slotmodelGamePluginCommonMpt.Log.loggers.exists(key)) {
                var value = slotmodelGamePluginCommonMpt.Log.logerFactory.getLogger(key);
                slotmodelGamePluginCommonMpt.Log.loggers.set(key, value);
            }
            return slotmodelGamePluginCommonMpt.Log.loggers.get(key);
        };
        slotmodelGamePluginCommonMpt.Log.getLogerFactory = function(context) {
            var loggerService = context.getAnyService(clientkernelLoggerApi.ILoggerFactory, null);
            if (loggerService != null) {
                if (_hcmn_.js_Boot.__instanceof(loggerService, clientkernelLoggerApi.ILoggerFactory)) return _hcmn_.js_Boot.__cast(loggerService, clientkernelLoggerApi.ILoggerFactory);
            }
            return null;
        };
        slotmodelGamePluginCommonMpt.Log.prototype.__class__ = slotmodelGamePluginCommonMpt.Log;
        slotmodelGamePluginCommonMpt.MptHelper = function() {};
        slotmodelGamePluginCommonMpt.MptHelper.__name__ = ["slotmodelGamePluginCommonMpt", "MptHelper"];
        slotmodelGamePluginCommonMpt.MptHelper.gameId = null;
        slotmodelGamePluginCommonMpt.MptHelper.onError = null;
        slotmodelGamePluginCommonMpt.MptHelper.payloadErrorId = null;
        slotmodelGamePluginCommonMpt.MptHelper.init = function(gId, onErr, pErrorId) {
            slotmodelGamePluginCommonMpt.MptHelper.gameId = gId;
            slotmodelGamePluginCommonMpt.MptHelper.onError = onErr;
            slotmodelGamePluginCommonMpt.MptHelper.payloadErrorId = pErrorId;
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMptGameOutcome = function(json) {
            var type = slotmodelGamePluginCommonMpt.StdHelper.getField(json, "@type");
            var gameOver = slotmodelGamePluginCommonMpt.StdHelper.getBoolField(json, "GameOver", false);
            var playerDecision = slotmodelGamePluginCommonMpt.StdHelper.getBoolField(json, "PlayerDecision", false);
            var choices = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Choices", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var nameDynamic = slotmodelGamePluginCommonMpt.StdHelper.getField(json, "name");
            var name = "";
            if (nameDynamic.length != 0) name = _hcmn_.Std.string(nameDynamic);
            var outcome = slotmodelGamePluginCommonMpt.MptHelper.getMOutcome(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "Outcome"));
            var awardCapped = slotmodelGamePluginCommonMpt.StdHelper.getBoolField(json, "AwardCapped", false);
            return new slotmodelGamePluginCommonMpt.MGameOutcome(type, gameOver, playerDecision, choices, name, outcome, awardCapped);
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMOutcome = function(json) {
            var nodeWinInfos = slotmodelGamePluginCommonMpt.MptHelper.getMNodeWinInfoArray(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "NodeWinInfos"));
            var currentNode = slotmodelGamePluginCommonMpt.MptHelper.getMNode(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "CurrentNode"));
            var nextNode = slotmodelGamePluginCommonMpt.MptHelper.getMNode(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "NextNode"));
            var selectedBet = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "SelectedBet", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var baseGameWin = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "BaseGameWin", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var featureWin = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "FeatureWin", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var totalWin = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "TotalWin", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var hasWinCappingOccured = slotmodelGamePluginCommonMpt.StdHelper.getBoolField(json, "HasWinCappingOccured", false);
            return new slotmodelGamePluginCommonMpt.MOutcome(nodeWinInfos, currentNode, nextNode, selectedBet, baseGameWin, featureWin, totalWin, hasWinCappingOccured);
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMNodeWinInfoArray = function(json) {
            var jsonArray = slotmodelGamePluginCommonMpt.MptHelper.arrayify(json);
            var result = [];
            var _g = 0;
            while (_g < jsonArray.length) {
                var json1 = jsonArray[_g];
                ++_g;
                result.push(slotmodelGamePluginCommonMpt.MptHelper.getMNodeWinInfo(json1));
            }
            return result;
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMNode = function(json) {
            var argument = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Argument", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var index = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Index", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            return new slotmodelGamePluginCommonMpt.MNode(argument, index);
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMNodeWinInfo = function(json) {
            var node = slotmodelGamePluginCommonMpt.MptHelper.getMNode(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "Node"));
            var win = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Win", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var winInfos = slotmodelGamePluginCommonMpt.MptHelper.getMWinInfoArray(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "WinInfos"));
            var reelPictureArray = slotmodelGamePluginCommonMpt.MptHelper.getIntMatrix(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "ReelPicture"));
            var stopPositions = "";
            var stopPositionsDynamic = slotmodelGamePluginCommonMpt.StdHelper.getField(json, "StopPositions");
            if (_hcmn_.Std.string(stopPositionsDynamic).length > 0) stopPositions = _hcmn_.Std.string(stopPositionsDynamic);
            return new slotmodelGamePluginCommonMpt.MNodeWinInfo(node, win, winInfos, reelPictureArray, stopPositions);
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMWinInfoArray = function(json) {
            var jsonArray = slotmodelGamePluginCommonMpt.MptHelper.arrayify(json);
            var result = [];
            if (jsonArray == null) return result;
            var _g = 0;
            while (_g < jsonArray.length) {
                var json1 = jsonArray[_g];
                ++_g;
                result.push(slotmodelGamePluginCommonMpt.MptHelper.getMWinInfo(json1));
            }
            return result;
        };
        slotmodelGamePluginCommonMpt.MptHelper.getMWinInfo = function(json) {
            var creditWin = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "CreditWin", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var sender = slotmodelGamePluginCommonMpt.MptHelper.getMNode(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "Sender"));
            var winType = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "WinType", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var basicWin = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "BasicWin", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var multiplier1 = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Multiplier1", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var multiplier2 = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Multiplier2", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var index = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Index", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var argument = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Argument", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var info = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "Info", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var infoString = _hcmn_.Std.string(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "InfoString"));
            var conditionId = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "ConditionId", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var lineNumber = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "LineNumber", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var autoInfo = slotmodelGamePluginCommonMpt.StdHelper.parseIntField(json, "AutoInfo", slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError);
            var symbol = slotmodelGamePluginCommonMpt.MptHelper.getIntMatrix(slotmodelGamePluginCommonMpt.StdHelper.getField(json, "Symbol"));
            return new slotmodelGamePluginCommonMpt.MWinInfo(creditWin, sender, winType, basicWin, multiplier1, multiplier2, index, argument, info, infoString, conditionId, lineNumber, autoInfo, symbol);
        };
        slotmodelGamePluginCommonMpt.MptHelper.arrayify = function(json) {
            var jsonArray = null;
            if ((json instanceof Array) && json.__enum__ == null) jsonArray = json;
            else {
                jsonArray = [];
                if (json != null && _hcmn_.js_Boot.__instanceof(json, _hcmn_.Dynamic)) jsonArray.push(json);
            }
            return jsonArray;
        };
        slotmodelGamePluginCommonMpt.MptHelper.getIntMatrix = function(json) {
            if (json == null) return null;
            if (Object.prototype.hasOwnProperty.call(json, "Rows")) {
                json = _hcmn_.Reflect.field(json, "Rows");
                if (json == null) return null;
            }
            if ((json instanceof Array) && json.__enum__ == null && json.length > 0 && !Object.prototype.hasOwnProperty.call(json[0], "Cells") && !((json[0] instanceof Array) && json[0].__enum__ == null)) {
                var tempMatrix = [];
                tempMatrix.push(json);
                json = tempMatrix;
            }
            var resultMatrix = [];
            var inputMatrixJson = json;
            var _g = 0;
            while (_g < inputMatrixJson.length) {
                var row = inputMatrixJson[_g];
                ++_g;
                var cellsArray = null;
                if (row != null && Object.prototype.hasOwnProperty.call(row, "Cells")) cellsArray = _hcmn_.Reflect.field(row, "Cells");
                else if ((row instanceof Array) && row.__enum__ == null) cellsArray = row;
                resultMatrix.push(cellsArray.map(_hcmn_.Std.parseInt));
            }
            return resultMatrix;
        };
        slotmodelGamePluginCommonMpt.MptHelper.onParseFatalError = function(message) {
            slotmodelGamePluginCommonMpt.Log.getLoggerBykey("MptHelper").error("[ParseFatalError]" + message);
            slotmodelGamePluginCommonMpt.MptHelper.onError(slotmodelGamePluginCommonMpt.MptHelper.getFatalError("ParseFatalError", message));
        };
        slotmodelGamePluginCommonMpt.MptHelper.getFatalError = function(source, message) {
            return new slotModelApi.Error(slotmodelGamePluginCommonMpt.MptHelper.payloadErrorId, true, "[" + slotmodelGamePluginCommonMpt.MptHelper.gameId + "][" + source + "] " + message);
        };
        slotmodelGamePluginCommonMpt.MptHelper.prototype.__class__ = slotmodelGamePluginCommonMpt.MptHelper;
        slotmodelGamePluginCommonMpt.StdHelper = function() {};
        slotmodelGamePluginCommonMpt.StdHelper.__name__ = ["slotmodelGamePluginCommonMpt", "StdHelper"];
        slotmodelGamePluginCommonMpt.StdHelper.isEmpty = function(value) {
            if (value == null) return true;
            if (value == "") return true;
            return false;
        };
        slotmodelGamePluginCommonMpt.StdHelper.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;
        };
        slotmodelGamePluginCommonMpt.StdHelper.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;
        };
        slotmodelGamePluginCommonMpt.StdHelper.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;
        };
        slotmodelGamePluginCommonMpt.StdHelper.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 slotmodelGamePluginCommonMpt.StdHelper.getField(field, remainingPath);
            }
            return null;
        };
        slotmodelGamePluginCommonMpt.StdHelper.getBoolField = function(object, name, defaultValue) {
            var dynammicValue = slotmodelGamePluginCommonMpt.StdHelper.getField(object, name);
            if (dynammicValue == null) return defaultValue;
            return _hcmn_.Std.string(dynammicValue).toLowerCase() == "true";
        };
        slotmodelGamePluginCommonMpt.StdHelper.getArrayField = function(object, name) {
            var field = slotmodelGamePluginCommonMpt.StdHelper.getField(object, name);
            return slotmodelGamePluginCommonMpt.StdHelper.getArray(field);
        };
        slotmodelGamePluginCommonMpt.StdHelper.getIntArrayField = function(object, name) {
            if (object == null) return null;
            var resultDynamicArray = slotmodelGamePluginCommonMpt.StdHelper.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;
        };
        slotmodelGamePluginCommonMpt.StdHelper.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 slotmodelGamePluginCommonMpt.StdHelper.getArray(slotmodelGamePluginCommonMpt.StdHelper.getField(json, namePath));
        };
        slotmodelGamePluginCommonMpt.StdHelper.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 slotmodelGamePluginCommonMpt.StdHelper.getField(json, namePath);
        };
        slotmodelGamePluginCommonMpt.StdHelper.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;
        };
        slotmodelGamePluginCommonMpt.StdHelper.parseIntField = function(object, name, onError) {
            var dynamicValue = slotmodelGamePluginCommonMpt.StdHelper.getField(object, name);
            if (dynamicValue == null) return null;
            return slotmodelGamePluginCommonMpt.StdHelper.parseInt(dynamicValue, onError);
        };
        slotmodelGamePluginCommonMpt.StdHelper.parseIntArrayField = function(object, name, onError) {
            if (object == null) return null;
            var resultDynamicArray = slotmodelGamePluginCommonMpt.StdHelper.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 = slotmodelGamePluginCommonMpt.StdHelper.parseInt(resultItem1, onError);
                if (item == null) return null;
                result.push(item);
            }
            return result;
        };
        slotmodelGamePluginCommonMpt.StdHelper.prototype.__class__ = slotmodelGamePluginCommonMpt.StdHelper;
        slotmodelGamePluginCommonMpt.Win = function(type, id, name, lineId) {
            this.type = type;
            this.id = id;
            this.name = name;
            this.lineId = lineId;
        };
        slotmodelGamePluginCommonMpt.Win = ck_implements(slotmodelGamePluginCommonMpt.Win, slotmodelGamePluginApi.IWin);
        slotmodelGamePluginCommonMpt.Win.__interfaces__ = [slotmodelGamePluginApi.IWin];
        slotmodelGamePluginCommonMpt.Win.__name__ = ["slotmodelGamePluginCommonMpt", "Win"];
        slotmodelGamePluginCommonMpt.Win.prototype.type = null;
        slotmodelGamePluginCommonMpt.Win.prototype.id = null;
        slotmodelGamePluginCommonMpt.Win.prototype.name = null;
        slotmodelGamePluginCommonMpt.Win.prototype.lineId = null;
        slotmodelGamePluginCommonMpt.Win.prototype.stakePerLineCredit = null;
        slotmodelGamePluginCommonMpt.Win.prototype.price = null;
        slotmodelGamePluginCommonMpt.Win.prototype.multiplier = null;
        slotmodelGamePluginCommonMpt.Win.prototype.payoutCredit = null;
        slotmodelGamePluginCommonMpt.Win.prototype.winPath = null;
        slotmodelGamePluginCommonMpt.Win.prototype.winningSymbol = null;
        slotmodelGamePluginCommonMpt.Win.prototype.position = null;
        slotmodelGamePluginCommonMpt.Win.prototype.symbolCount = null;
        slotmodelGamePluginCommonMpt.Win.prototype.setWinPath = function(value) {
            this.winPath = value;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.setPayProperties = function(stakePerLineCredit, price, multiplier, payoutCredit) {
            this.stakePerLineCredit = stakePerLineCredit;
            this.price = price;
            this.multiplier = multiplier;
            this.payoutCredit = payoutCredit;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.setRenderProperties = function(winningSymbol, position, symbolCount) {
            this.winningSymbol = winningSymbol;
            this.position = position;
            this.symbolCount = symbolCount;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getType = function() {
            return this.type;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getId = function() {
            return this.id;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getName = function() {
            return this.name;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getLineId = function() {
            return this.lineId;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getStakePerLineCredit = function() {
            return this.stakePerLineCredit;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getPrice = function() {
            return this.price;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getMultiplier = function() {
            return this.multiplier;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getPayoutCredit = function() {
            return this.payoutCredit;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getWinPath = function() {
            return this.winPath;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getWinningSymbol = function() {
            return this.winningSymbol;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getPosition = function() {
            return this.position;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.getSymbolCount = function() {
            return this.symbolCount;
        };
        slotmodelGamePluginCommonMpt.Win.prototype.__class__ = slotmodelGamePluginCommonMpt.Win;
        slotmodelGamePluginCommonMpt.BonusWin = function(type, id, name, lineId) {
            slotmodelGamePluginCommonMpt.Win.call(this, type, id, name, lineId);
        };
        slotmodelGamePluginCommonMpt.BonusWin = ck_implements(slotmodelGamePluginCommonMpt.BonusWin, slotmodelGamePluginApi.IBonusWin);
        slotmodelGamePluginCommonMpt.BonusWin.__interfaces__ = [slotmodelGamePluginApi.IBonusWin];
        slotmodelGamePluginCommonMpt.BonusWin.__name__ = ["slotmodelGamePluginCommonMpt", "BonusWin"];
        slotmodelGamePluginCommonMpt.BonusWin.__super__ = slotmodelGamePluginCommonMpt.Win;
        for (var k in slotmodelGamePluginCommonMpt.Win.prototype) slotmodelGamePluginCommonMpt.BonusWin.prototype[k] = slotmodelGamePluginCommonMpt.Win.prototype[k];
        slotmodelGamePluginCommonMpt.BonusWin.prototype.__class__ = slotmodelGamePluginCommonMpt.BonusWin;
        slotmodelGamePluginCommonMpt.FreeSpinInfo = function(awarded, isMaxAwarded, isIncrementTriggered, total, current) {
            this.awarded = awarded;
            this.isMaxAwarded = isMaxAwarded;
            this.isIncrementTriggered = isIncrementTriggered;
            this.total = total;
            this.current = current;
        };
        slotmodelGamePluginCommonMpt.FreeSpinInfo.__name__ = ["slotmodelGamePluginCommonMpt", "FreeSpinInfo"];
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.awarded = null;
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.isMaxAwarded = null;
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.isIncrementTriggered = null;
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.current = null;
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.total = null;
        slotmodelGamePluginCommonMpt.FreeSpinInfo.prototype.__class__ = slotmodelGamePluginCommonMpt.FreeSpinInfo;
        slotmodelGamePluginCommonMpt.LineWin = function(lineId, name) {
            var id = slotmodelGamePluginCommonMpt.LineWin.WIN_TYPE + "_" + lineId;
            slotmodelGamePluginCommonMpt.Win.call(this, slotmodelGamePluginCommonMpt.LineWin.WIN_TYPE, id, name, lineId);
        };
        slotmodelGamePluginCommonMpt.LineWin = ck_implements(slotmodelGamePluginCommonMpt.LineWin, slotmodelGamePluginApi.ILineWin);
        slotmodelGamePluginCommonMpt.LineWin.__interfaces__ = [slotmodelGamePluginApi.ILineWin];
        slotmodelGamePluginCommonMpt.LineWin.__name__ = ["slotmodelGamePluginCommonMpt", "LineWin"];
        slotmodelGamePluginCommonMpt.LineWin.__super__ = slotmodelGamePluginCommonMpt.Win;
        for (var k in slotmodelGamePluginCommonMpt.Win.prototype) slotmodelGamePluginCommonMpt.LineWin.prototype[k] = slotmodelGamePluginCommonMpt.Win.prototype[k];
        slotmodelGamePluginCommonMpt.LineWin.prototype.setRenderProperties = function(winningSymbol, positionHidden, symbolCount) {
            slotmodelGamePluginCommonMpt.Win.prototype.setRenderProperties.call(this, winningSymbol, slotmodelGamePluginCommonMpt.LineWin.WIN_POSITION, symbolCount);
        };
        slotmodelGamePluginCommonMpt.LineWin.prototype.__class__ = slotmodelGamePluginCommonMpt.LineWin;
        slotmodelGamePluginCommonMpt.Outcome = function() {};
        slotmodelGamePluginCommonMpt.Outcome = ck_implements(slotmodelGamePluginCommonMpt.Outcome, slotmodelGamePluginApi.IOutcome);
        slotmodelGamePluginCommonMpt.Outcome.__interfaces__ = [slotmodelGamePluginApi.IOutcome];
        slotmodelGamePluginCommonMpt.Outcome.__name__ = ["slotmodelGamePluginCommonMpt", "Outcome"];
        slotmodelGamePluginCommonMpt.Outcome.prototype.stage = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.reelStop = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.reelStopAdditional = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.lineWins = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.scatterWins = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.bonusWins = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.pickerWins = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.customField = null;
        slotmodelGamePluginCommonMpt.Outcome.prototype.setStage = function(value) {
            this.stage = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setReelStop = function(value) {
            this.reelStop = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setReelStopAdditional = function(value) {
            this.reelStopAdditional = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setLineWins = function(value) {
            this.lineWins = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setScatterWins = function(value) {
            this.scatterWins = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setBonusWins = function(value) {
            this.bonusWins = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setPickerWins = function(value) {
            this.pickerWins = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.setCustomField = function(value) {
            this.customField = value;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getCustomField = function() {
            return this.customField;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getStage = function() {
            return this.stage;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getReelStop = function() {
            return this.reelStop;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getReelStopAdditional = function() {
            return this.reelStopAdditional;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getLineWins = function() {
            return this.lineWins;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getScatterWins = function() {
            return this.scatterWins;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getBonusWins = function() {
            return this.bonusWins;
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.getPickerWins = function() {
            return this.pickerWins;
        };
        slotmodelGamePluginCommonMpt.Outcome.create = function(stage, reelStop, reelStopAdditional, lineWins, scatterWins, bonusWins, pickerWins, customField) {
            var result = new slotmodelGamePluginCommonMpt.Outcome();
            result.setStage(stage);
            result.setReelStop(reelStop);
            result.setReelStopAdditional(reelStopAdditional);
            result.setLineWins(lineWins);
            result.setScatterWins(scatterWins);
            result.setBonusWins(bonusWins);
            result.setPickerWins(pickerWins);
            result.setCustomField(customField);
            return result;
        };
        slotmodelGamePluginCommonMpt.Outcome.create2 = function(stage, reelStop) {
            return slotmodelGamePluginCommonMpt.Outcome.create(stage, reelStop, null, null, null, null, null, null);
        };
        slotmodelGamePluginCommonMpt.Outcome.prototype.__class__ = slotmodelGamePluginCommonMpt.Outcome;
        slotmodelGamePluginCommonMpt.PickerWin = function(type, id, name, lineId, picks) {
            slotmodelGamePluginCommonMpt.Win.call(this, type, id, name, lineId);
            this.picks = picks;
        };
        slotmodelGamePluginCommonMpt.PickerWin = ck_implements(slotmodelGamePluginCommonMpt.PickerWin, slotmodelGamePluginApi.IPickerWin);
        slotmodelGamePluginCommonMpt.PickerWin.__interfaces__ = [slotmodelGamePluginApi.IPickerWin];
        slotmodelGamePluginCommonMpt.PickerWin.__name__ = ["slotmodelGamePluginCommonMpt", "PickerWin"];
        slotmodelGamePluginCommonMpt.PickerWin.__super__ = slotmodelGamePluginCommonMpt.Win;
        for (var k in slotmodelGamePluginCommonMpt.Win.prototype) slotmodelGamePluginCommonMpt.PickerWin.prototype[k] = slotmodelGamePluginCommonMpt.Win.prototype[k];
        slotmodelGamePluginCommonMpt.PickerWin.prototype.picks = null;
        slotmodelGamePluginCommonMpt.PickerWin.prototype.__class__ = slotmodelGamePluginCommonMpt.PickerWin;
        slotmodelGamePluginCommonMpt.ScatterWin = function(name) {
            var id = slotmodelGamePluginCommonMpt.ScatterWin.WIN_TYPE + "_" + name;
            slotmodelGamePluginCommonMpt.Win.call(this, slotmodelGamePluginCommonMpt.ScatterWin.WIN_TYPE, id, name, slotmodelGamePluginCommonMpt.ScatterWin.WIN_LINEID);
        };
        slotmodelGamePluginCommonMpt.ScatterWin = ck_implements(slotmodelGamePluginCommonMpt.ScatterWin, slotmodelGamePluginApi.IScatterWin);
        slotmodelGamePluginCommonMpt.ScatterWin.__interfaces__ = [slotmodelGamePluginApi.IScatterWin];
        slotmodelGamePluginCommonMpt.ScatterWin.__name__ = ["slotmodelGamePluginCommonMpt", "ScatterWin"];
        slotmodelGamePluginCommonMpt.ScatterWin.__super__ = slotmodelGamePluginCommonMpt.Win;
        for (var k in slotmodelGamePluginCommonMpt.Win.prototype) slotmodelGamePluginCommonMpt.ScatterWin.prototype[k] = slotmodelGamePluginCommonMpt.Win.prototype[k];
        slotmodelGamePluginCommonMpt.ScatterWin.prototype.setRenderProperties = function(winningSymbol, positionHidden, symbolCount) {
            slotmodelGamePluginCommonMpt.Win.prototype.setRenderProperties.call(this, winningSymbol, slotmodelGamePluginCommonMpt.ScatterWin.WIN_POSITION, symbolCount);
        };
        slotmodelGamePluginCommonMpt.ScatterWin.prototype.__class__ = slotmodelGamePluginCommonMpt.ScatterWin;
        slotmodelGamePluginCommonMpt.ECondition = function() {};
        slotmodelGamePluginCommonMpt.ECondition.__name__ = ["slotmodelGamePluginCommonMpt", "ECondition"];
        slotmodelGamePluginCommonMpt.ECondition.prototype.__class__ = slotmodelGamePluginCommonMpt.ECondition;
        slotmodelGamePluginCommonMpt.EReelPictureInfo = function(value) {
            this.value = 0;
            this.value = value;
        };
        slotmodelGamePluginCommonMpt.EReelPictureInfo.__name__ = ["slotmodelGamePluginCommonMpt", "EReelPictureInfo"];
        slotmodelGamePluginCommonMpt.EReelPictureInfo.prototype.value = null;
        slotmodelGamePluginCommonMpt.EReelPictureInfo.ofSymbol = function(symbol) {
            switch (symbol) {
                case 0:
                    return slotmodelGamePluginCommonMpt.EReelPictureInfo.NONE;
                case 254:
                    return slotmodelGamePluginCommonMpt.EReelPictureInfo.INACTIVE;
                default:
                    return slotmodelGamePluginCommonMpt.EReelPictureInfo.ACTIVE;
            }
        };
        slotmodelGamePluginCommonMpt.EReelPictureInfo.prototype.__class__ = slotmodelGamePluginCommonMpt.EReelPictureInfo;
        slotmodelGamePluginCommonMpt.EWinInfo = function() {};
        slotmodelGamePluginCommonMpt.EWinInfo.__name__ = ["slotmodelGamePluginCommonMpt", "EWinInfo"];
        slotmodelGamePluginCommonMpt.EWinInfo.prototype.__class__ = slotmodelGamePluginCommonMpt.EWinInfo;
        slotmodelGamePluginCommonMpt.MGameOutcome = function(type, gameOver, playerDecision, choices, name, outcome, awardCapped) {
            this.type = type;
            this.gameOver = gameOver;
            this.playerDecision = playerDecision;
            this.choices = choices;
            this.name = name;
            this.outcome = outcome;
            this.awardCapped = awardCapped;
        };
        slotmodelGamePluginCommonMpt.MGameOutcome.__name__ = ["slotmodelGamePluginCommonMpt", "MGameOutcome"];
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.type = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.gameOver = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.playerDecision = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.choices = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.name = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.outcome = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.awardCapped = null;
        slotmodelGamePluginCommonMpt.MGameOutcome.prototype.__class__ = slotmodelGamePluginCommonMpt.MGameOutcome;
        slotmodelGamePluginCommonMpt.MNode = function(argument, index) {
            this.argument = argument;
            this.index = index;
        };
        slotmodelGamePluginCommonMpt.MNode.__name__ = ["slotmodelGamePluginCommonMpt", "MNode"];
        slotmodelGamePluginCommonMpt.MNode.prototype.argument = null;
        slotmodelGamePluginCommonMpt.MNode.prototype.index = null;
        slotmodelGamePluginCommonMpt.MNode.prototype.__class__ = slotmodelGamePluginCommonMpt.MNode;
        slotmodelGamePluginCommonMpt.MNodeWinInfo = function(node, win, winInfos, reelPicture, stopPositions) {
            this.node = node;
            this.win = win;
            this.winInfos = winInfos;
            this.reelPicture = reelPicture;
            this.stopPositions = stopPositions;
        };
        slotmodelGamePluginCommonMpt.MNodeWinInfo.__name__ = ["slotmodelGamePluginCommonMpt", "MNodeWinInfo"];
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.node = null;
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.win = null;
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.winInfos = null;
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.reelPicture = null;
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.stopPositions = null;
        slotmodelGamePluginCommonMpt.MNodeWinInfo.prototype.__class__ = slotmodelGamePluginCommonMpt.MNodeWinInfo;
        slotmodelGamePluginCommonMpt.MOutcome = function(nodeWinInfos, currentNode, nextNode, selectedBet, baseGameWin, featureWin, totalWin, hasWinCappingOccured) {
            this.nodeWinInfos = nodeWinInfos;
            this.currentNode = currentNode;
            this.nextNode = nextNode;
            this.selectedBet = selectedBet;
            this.baseGameWin = baseGameWin;
            this.featureWin = featureWin;
            this.totalWin = totalWin;
            this.hasWinCappingOccured = hasWinCappingOccured;
        };
        slotmodelGamePluginCommonMpt.MOutcome.__name__ = ["slotmodelGamePluginCommonMpt", "MOutcome"];
        slotmodelGamePluginCommonMpt.MOutcome.prototype.nodeWinInfos = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.currentNode = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.nextNode = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.selectedBet = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.baseGameWin = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.featureWin = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.totalWin = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.hasWinCappingOccured = null;
        slotmodelGamePluginCommonMpt.MOutcome.prototype.__class__ = slotmodelGamePluginCommonMpt.MOutcome;
        slotmodelGamePluginCommonMpt.MWinInfo = function(creditWin, sender, winType, basicWin, multiplier1, multiplier2, index, argument, info, infoString, conditionId, lineNumber, autoInfo, symbol) {
            this.creditWin = creditWin;
            this.sender = sender;
            this.winType = winType;
            this.basicWin = basicWin;
            this.multiplier1 = multiplier1;
            this.multiplier2 = multiplier2;
            this.index = index;
            this.argument = argument;
            this.info = info;
            this.infoString = infoString;
            this.conditionId = conditionId;
            this.lineNumber = lineNumber;
            this.autoInfo = autoInfo;
            this.symbol = symbol;
        };
        slotmodelGamePluginCommonMpt.MWinInfo.__name__ = ["slotmodelGamePluginCommonMpt", "MWinInfo"];
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.creditWin = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.sender = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.winType = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.basicWin = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.multiplier1 = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.multiplier2 = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.index = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.argument = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.info = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.infoString = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.conditionId = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.lineNumber = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.autoInfo = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.symbol = null;
        slotmodelGamePluginCommonMpt.MWinInfo.prototype.__class__ = slotmodelGamePluginCommonMpt.MWinInfo;
        slotmodelGamePluginCommonMpt.Log.loggers = new _hcmn_.haxe_ds_StringMap();;
        slotmodelGamePluginCommonMpt.LineWin.WIN_TYPE = "Line";;
        slotmodelGamePluginCommonMpt.LineWin.WIN_POSITION = 0;;
        slotmodelGamePluginCommonMpt.PickerWin.WIN_TYPE = "Picker";;
        slotmodelGamePluginCommonMpt.ScatterWin.WIN_TYPE = "Scatter";;
        slotmodelGamePluginCommonMpt.ScatterWin.WIN_LINEID = 0;;
        slotmodelGamePluginCommonMpt.ScatterWin.WIN_POSITION = 0;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE = 1;;
        slotmodelGamePluginCommonMpt.ECondition._c_LINE_LEFT = 2;;
        slotmodelGamePluginCommonMpt.ECondition._c_LINE_RIGHT = 3;;
        slotmodelGamePluginCommonMpt.ECondition._c_LINE_ANY = 4;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELS_ANY = 5;;
        slotmodelGamePluginCommonMpt.ECondition._c_RESPIN_REELS_ANY = 6;;
        slotmodelGamePluginCommonMpt.ECondition._c_PLAYER_DECISION = 7;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_SEND_FILTERED_STATE = 8;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_NR_NEXT_RESULT = 9;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_DRAWGAME_STATE = 10;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELS_LEFT = 11;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELS_RIGHT = 12;;
        slotmodelGamePluginCommonMpt.ECondition._c_REGISTER = 13;;
        slotmodelGamePluginCommonMpt.ECondition._c_REGISTER_DRAWGAME_STATE = 14;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELSHAPE_LEFT = 15;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELSHAPE_RIGHT = 16;;
        slotmodelGamePluginCommonMpt.ECondition._c_REELSHAPE_ANY = 17;;
        slotmodelGamePluginCommonMpt.ECondition._c_BALANCED_OPTION = 18;;
        slotmodelGamePluginCommonMpt.ECondition._c_LINESHAPE_LEFT = 19;;
        slotmodelGamePluginCommonMpt.ECondition._c_LINESHAPE_RIGHT = 20;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_SEND_PLAYER_DECISION = 21;;
        slotmodelGamePluginCommonMpt.ECondition._c_MULTIWAY_LEFT = 22;;
        slotmodelGamePluginCommonMpt.ECondition._c_MULTIWAY_RIGHT = 23;;
        slotmodelGamePluginCommonMpt.ECondition._c_MULTIWAY_ANY = 24;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_SEND_FILTERED_STATE_32 = 25;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_DRAWGAME_STATE_32 = 26;;
        slotmodelGamePluginCommonMpt.ECondition._c_REGISTER_DRAWGAME_STATE_32 = 27;;
        slotmodelGamePluginCommonMpt.ECondition._c_HITSHAPE_LEFT = 28;;
        slotmodelGamePluginCommonMpt.ECondition._c_HITSHAPE_RIGHT = 29;;
        slotmodelGamePluginCommonMpt.ECondition._c_HITSHAPE_ANY = 30;;
        slotmodelGamePluginCommonMpt.ECondition._c_TRUE_NRS_NEXT_RESULT = 31;;
        slotmodelGamePluginCommonMpt.ECondition.__MAX_c_CONDITION_TYPES = 256;;
        slotmodelGamePluginCommonMpt.EReelPictureInfo.NONE = new slotmodelGamePluginCommonMpt.EReelPictureInfo(0);;
        slotmodelGamePluginCommonMpt.EReelPictureInfo.ACTIVE = new slotmodelGamePluginCommonMpt.EReelPictureInfo(1);;
        slotmodelGamePluginCommonMpt.EReelPictureInfo.INACTIVE = new slotmodelGamePluginCommonMpt.EReelPictureInfo(2);;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_TYPE_CREDIT = 0;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_TYPE_TRIGGER_COUNTER = 1;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_TYPE_CONSOLATION = 2;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_TYPE_FILTEREDSTATE = 3;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_TYPE_POT_PAYOUT = 4;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_AUTO_TYPE_JACKPOT = 128;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_AUTO_TYPE_TRIGGER = 129;;
        slotmodelGamePluginCommonMpt.EWinInfo.WIN_AUTO_TYPE_POT_MODIFY = 130;;
        slotmodelGamePluginCommonMpt.EWinInfo.__MAX_WIN_TYPES = 256;;
        return {
            exports: slotmodelGamePluginCommonMpt
        };
    });
//# sourceURL=slotModelGamePluginCommonMpt.js