include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib_h"

include "TriggerLibs/GameLib_h"

include "TriggerLibs/MapMechanicsLib_h"

include "TriggerLibs/AILib_h"

include "TriggerLibs/UILib_h"

include "TriggerLibs/StartingExperienceLib_h"

include "TriggerLibs/SoundLib_h"

include "TriggerLibs/GameDataHelperLib_h"



include "TriggerLibs/SupportLib_h"



//--------------------------------------------------------------------------------------------------

// Library: Support

//--------------------------------------------------------------------------------------------------

// External Library Initialization

void libSprt_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libMapM_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

    libStEx_InitVariables();

    libSond_InitVariables();

    libGDHL_InitVariables();

}



// Variable Initialization

bool libSprt_InitVariables_completed = false;



void libSprt_InitVariables () {

    int init_i;



    if (libSprt_InitVariables_completed) {

        return;

    }



    libSprt_InitVariables_completed = true;



    libSprt_gv_dataMiningPeriodicTimer = TimerCreate();

    for (init_i = 0; init_i <= libSprt_gv_dataMiningMaxNumberOfDifferentManaRegenSources; init_i += 1) {

        libSprt_gv_dataMiningManaRegenSourceNames[init_i] = "";

    }

    libSprt_gv_heroMasteryRingsMaxRank = 3;

    libSprt_gv_qACheatsSpawnedUnitsGroup = UnitGroupEmpty();

    libSprt_gv_qACheatsSelectedBehavior = 1;

    libSprt_gv_qACheatsSelectedSpawnUnit = 1;

    libSprt_gv_qACheatsControlsPanel.lv_mainDialog = c_invalidDialogId;

    libSprt_gv_qACheatsControlsPanel.lv_behaviorApplyButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_behaviorRemoveButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_behaviorCleanseButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_behaviorListPulldown = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_alliedControlCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_cooldownsCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_showMapCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_visionCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_gridCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_tVECheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_freeCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_toggleSelectionCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_toggleWeaponsCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_speedCountEditbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_executeSpeedButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_spawnUnitListPulldown = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_neutralCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_spawnUnitButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_closeButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_debugKillButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_refreshUnitButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_moveUnitButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_refreshCooldownsButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_cameraAngleEditbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_toggleDebugCameraCheckbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_setCameraAngleButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_debugRespawnButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_spawnItemListPulldown = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_itemCountEditbox = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_spawnItemButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_respawnStructuresButton = c_invalidDialogControlId;

    libSprt_gv_qACheatsControlsPanel.lv_killStructuresButton = c_invalidDialogControlId;

    for (init_i = 0; init_i <= 30; init_i += 1) {

        libSprt_gv_compiledBehaviorList[init_i] = "";

    }

    for (init_i = 0; init_i <= 30; init_i += 1) {

        libSprt_gv_qACheatsCompiledSpawnUnitsList[init_i] = "";

    }

    for (init_i = 0; init_i <= 5; init_i += 1) {

        libSprt_gv_qACheatsCompiledSpawnItemsList[init_i] = "";

    }

    libSprt_gv_dEBUGBalanceProbeTimer = TimerCreate();

    libSprt_gv_soundRepeatDelay = 3.0;

    libSprt_gv_dEBUGXPBoostMultiplier = 2.0;

    libSprt_gv_dEBUGXPPassiveBoostMultiplier = 1.0;

    libSprt_gv_dEBUGXPSourceHero = true;

    libSprt_gv_dEBUGXPSourceMinion = true;

    libSprt_gv_dEBUGXPSourceStructure = true;

    libSprt_gv_dEBUGXPSourceCreep = true;

    libSprt_gv_dEBUGCombatTextEnabled = true;

    libSprt_gv_dEBUGDebugMessagesEnabled = true;

    libSprt_gv_dEBUGMapTextEnabled = true;

    libSprt_gv_dEBUGDPSTrackerGroup = UnitGroupEmpty();

    libSprt_gv_dEBUGDPSTrackerTimer = TimerCreate();

}



// Functions

void libSprt_gf_PerformanceTestStartPerformanceTest (string lp_name) {

    // Automatic Variable Declarations

    // Implementation

    UnitStatsStart(StringToText(lp_name), StringExternal("Param/Value/lib_Sprt_4E3C325E"), StringExternal("Param/Value/lib_Sprt_22E09DDC"));

    PerfTestStart(StringToText(lp_name));

}



void libSprt_gf_PerformanceTestStopPerformanceTest () {

    // Automatic Variable Declarations

    // Implementation

    UnitStatsStop();

    PerfTestStop();

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_EBB0E5D4"), true);

}



void libSprt_gf_PerformanceTestHeroSelectScreen () {

    // Automatic Variable Declarations

    // Implementation

    libGame_gv_players[1].lv_heroIndex = 1;

    libCore_gf_DataLoadHeroDataIntoIndex(libCore_gf_GetHeroFromIndex(libGame_gv_players[1].lv_heroIndex), 1);

    Wait(2.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_B353FF5C"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Hero Select Screen");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestHeroesIdleBeforeGame () {

    // Variable Declarations

    int lv_loop;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    Wait(8.0, c_timeGame);

    CameraPan(1, UnitGroupCenterOfGroup(UnitGroupSelected(1)), 0.0, -1, 0.0, false);

    CameraFollowUnitGroup(1, UnitGroupSelected(1), true, false);

    CameraLockInput(1, true);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_3E5AD420"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Idle Before Game");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestHeroesIdleGameStart () {

    // Automatic Variable Declarations

    // Implementation

    Wait(8.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DEACEE4E"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Heroes Idle Game Start");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestHeroesIdleMinionsFighting () {

    // Automatic Variable Declarations

    // Implementation

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_6EA60DAC"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Heroes Idle Minions Fighting");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestTwoHeroesActiveStart () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    CameraPan(1, UnitGroupCenterOfGroup(UnitGroupSelected(1)), 0.0, -1, 0.0, false);

    CameraFollowUnitGroup(1, UnitGroupSelected(1), true, false);

    CameraLockInput(1, true);

    libAIAI_gf_HeroAITakeOverHeroForPlayer(1);

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 1));

    Wait(2.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DFF38BE8"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Two Heroes Activated");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestTwoHeroesActiveInLane () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E2FFA4A2"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Two Heroes In Lane");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestSixHeroesActiveStart () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 2));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 2));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 3));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 3));

    Wait(2.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DE92DCE3"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Six Heroes Activated");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestSixHeroesActiveInLane () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_28410EBD"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Six Heroes In Lane");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestTenHeroesActiveStart () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 4));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 4));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 5));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 5));

    Wait(2.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_AF3E0FFC"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Ten Heroes Activated");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestTenHeroesActiveInLane () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DEBDCE94"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Ten Heroes In Lane");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestChaosTeamDisabled () {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    playergroup auto413D494B_g;



    // Variable Initialization



    // Implementation

    auto413D494B_g = libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup;

    lv_player = -1;

    while (true) {

        	lv_player = PlayerGroupNextPlayer(auto413D494B_g, lv_player);

        	if (lv_player<0) { break; }

        	if ((lv_player <= libCore_gv_bALMaxPlayers)) {

            libAIAI_gf_HeroAIDisableAIForPlayer(lv_player);

            UnitKill(libGame_gv_players[lv_player].lv_heroUnit);

        }



    }

    Wait(2.0, c_timeGame);

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E52CD5EA"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Chaos Team Disabled");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



void libSprt_gf_PerformanceTestOrderTeamPushingUnopposed () {

    // Variable Declarations

    unit lv_hero;

    int lv_ownerPlayer;

    int lv_waveIndex;

    point lv_positionOfHero;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_0104DDDC"), true);

    libSprt_gf_PerformanceTestStartPerformanceTest("Order Team Pushing");

    Wait(10.0, c_timeGame);

    libSprt_gf_PerformanceTestStopPerformanceTest();

}



int libSprt_gf_StatTrackingGetTrackedPlayerFromString (string lp_chatString) {

    // Variable Declarations

    int lv_trackerPlayerHeroIndex;

    string lv_trackerPlayerHero;

    string lv_trackerPlayerStr;

    int lv_trackerPlayer;

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int autoF8F1686B_ae = libCore_gv_bALMaxPlayers;

    const int autoF8F1686B_ai = 1;



    // Variable Initialization

    lv_trackerPlayerStr = "";



    // Implementation

    lv_trackerPlayerStr = StringWord(lp_chatString, 2);

    if ((StringToInt(lv_trackerPlayerStr) >= 1) && (StringToInt(lv_trackerPlayerStr) <= libCore_gv_bALMaxPlayers)) {

        return StringToInt(lv_trackerPlayerStr);

    }

    else {

        lv_trackerPlayerHero = (lv_trackerPlayerStr);

        if ((libCore_gf_GetIndexFromHero(lv_trackerPlayerHero) > 0)) {

            lv_itPlayer = 1;

            for ( ; ( (autoF8F1686B_ai >= 0 && lv_itPlayer <= autoF8F1686B_ae) || (autoF8F1686B_ai < 0 && lv_itPlayer >= autoF8F1686B_ae) ) ; lv_itPlayer += autoF8F1686B_ai ) {

                if ((libGame_gv_players[lv_itPlayer].lv_heroData.lv_heroCatalogLink == lv_trackerPlayerHero)) {

                    return lv_itPlayer;

                }



            }

        }



    }

    TextExpressionSetToken("Param/Expression/lib_Sprt_AD72EB89", "A", StringToText(lv_trackerPlayerStr));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_AD72EB89"), true);

    return 0;

}



void libSprt_gf_StatTrackingStartTrackingforPlayer (int lp_player) {

    // Automatic Variable Declarations

    // Implementation

    if ((libSprt_gv_statTrackingOn[lp_player] == true)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_14ECA2B5", "A", IntToText(lp_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_14ECA2B5"), true);

        return ;

    }



    libSprt_gv_statTrackingPlayers += 1;

    if ((TriggerIsEnabled(libSprt_gt_StatTrackingDamageTracking) == false)) {

        TriggerEnable(libSprt_gt_StatTrackingDamageTracking, true);

        TriggerEnable(libSprt_gt_StatTrackingHealingTracking, true);

    }



    libSprt_gv_statTrackingOn[lp_player] = true;

    libSprt_gv_statTrackingStartTime[lp_player] = TimerGetElapsed(libGame_gv_gameTimer);

}



void libSprt_gf_StatTrackingBreakTrackingforPlayer (int lp_player) {

    // Automatic Variable Declarations

    // Implementation

    if ((libSprt_gv_statTrackingOn[lp_player] == true)) {

        libSprt_gf_StatTrackingReportStats(lp_player);

        libSprt_gv_statTrackingStartTime[lp_player] = TimerGetElapsed(libGame_gv_gameTimer);

        TextExpressionSetToken("Param/Expression/lib_Sprt_237EE8E2", "A", IntToText(lp_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_237EE8E2"), true);

    }



}



void libSprt_gf_StatTrackingStopTrackingforPlayer (int lp_player) {

    // Automatic Variable Declarations

    // Implementation

    if ((libSprt_gv_statTrackingOn[lp_player] == false)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_9EB0272F", "A", IntToText(lp_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_9EB0272F"), true);

        return ;

    }



    libSprt_gf_StatTrackingReportStats(lp_player);

    libSprt_gv_statTrackingOn[lp_player] = false;

    libSprt_gv_statTrackingPlayers -= 1;

    if ((libSprt_gv_statTrackingPlayers == 0)) {

        TriggerEnable(libSprt_gt_StatTrackingDamageTracking, false);

        TriggerEnable(libSprt_gt_StatTrackingHealingTracking, false);

    }



}



void libSprt_gf_StatTrackingReportStats (int lp_reportPlayer) {

    // Variable Declarations

    int lv_entriesInDataTable;

    int lv_itEntry;

    string lv_reportPlayerAsStr;

    string lv_dataTableName;

    string lv_effectName;

    int lv_itTalent;

    text lv_talentTextLine;

    fixed lv_gameSeconds;



    // Automatic Variable Declarations

    int auto4DC7E54B_ae;

    const int auto4DC7E54B_ai = 1;

    int auto98AE91C5_ae;

    const int auto98AE91C5_ai = 1;

    const int autoFCC81157_ae = libCore_gv_talents_MaxTiers_C;

    const int autoFCC81157_ai = 1;



    // Variable Initialization

    lv_reportPlayerAsStr = "";

    lv_dataTableName = "";

    lv_effectName = "";



    // Implementation

    lv_entriesInDataTable = DataTableValueCount(true);

    if ((lv_entriesInDataTable == 0)) {

        return ;

    }



    lv_gameSeconds = (TimerGetElapsed(libGame_gv_gameTimer) - libSprt_gv_statTrackingStartTime[lp_reportPlayer]);

    TriggerDebugOutput(7, StringExternal("Param/Value/lib_Sprt_63F766C8"), false);

    TextExpressionSetToken("Param/Expression/lib_Sprt_C2B10209", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(libSprt_gv_statTrackingStartTime[lp_reportPlayer])));

    TextExpressionSetToken("Param/Expression/lib_Sprt_C2B10209", "B", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(TimerGetElapsed(libGame_gv_gameTimer))));

    TextExpressionSetToken("Param/Expression/lib_Sprt_C2B10209", "C", UnitTypeGetName(UnitGetType(libGame_gv_players[lp_reportPlayer].lv_heroUnit)));

    TextExpressionSetToken("Param/Expression/lib_Sprt_C2B10209", "D", libGame_gv_players[lp_reportPlayer].lv_name);

    TextExpressionSetToken("Param/Expression/lib_Sprt_C2B10209", "E", FixedToText(lv_gameSeconds, c_fixedPrecisionAny));

    TriggerDebugOutput(7, TextExpressionAssemble("Param/Expression/lib_Sprt_C2B10209"), false);

    lv_reportPlayerAsStr = IntToString(lp_reportPlayer);

    auto4DC7E54B_ae = DataTableGetInt(true, ("DMGStatTrackPlayer" + lv_reportPlayerAsStr + ":EffectInstanceCount"));

    lv_itEntry = 1;

    for ( ; ( (auto4DC7E54B_ai >= 0 && lv_itEntry <= auto4DC7E54B_ae) || (auto4DC7E54B_ai < 0 && lv_itEntry >= auto4DC7E54B_ae) ) ; lv_itEntry += auto4DC7E54B_ai ) {

        lv_effectName = DataTableGetString(true, ("DMGStatTrackPlayer" + lv_reportPlayerAsStr + ":Effect" + IntToString(lv_itEntry)));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "D", StringToText(lv_effectName));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "A", IntToText(DataTableGetInt(true, ("DMG" + lv_effectName + "Heroic:EffectCount" + IntToString(lp_reportPlayer)))));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "B", FixedToText(DataTableGetFixed(true, ("DMG" + lv_effectName + "Heroic:DamageAttempted" + IntToString(lp_reportPlayer))), 0));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "C", FixedToText(DataTableGetFixed(true, ("DMG" + lv_effectName + "Heroic:DamageDone" + IntToString(lp_reportPlayer))), 0));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "E", IntToText(DataTableGetInt(true, ("DMG" + lv_effectName + ":EffectCount" + IntToString(lp_reportPlayer)))));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "F", FixedToText(DataTableGetFixed(true, ("DMG" + lv_effectName + ":DamageAttempted" + IntToString(lp_reportPlayer))), 0));

        TextExpressionSetToken("Param/Expression/lib_Sprt_7E978CA8", "G", FixedToText(DataTableGetFixed(true, ("DMG" + lv_effectName + ":DamageDone" + IntToString(lp_reportPlayer))), 0));

        TriggerDebugOutput(7, TextExpressionAssemble("Param/Expression/lib_Sprt_7E978CA8"), false);

        DataTableSetString(true, ("DMGStatTrackPlayer" + lv_reportPlayerAsStr + ":Effect" + IntToString(lv_itEntry)), "");

        DataTableSetInt(true, ("DMG" + lv_effectName + "Heroic:EffectCount" + IntToString(lp_reportPlayer)), 0);

        DataTableSetFixed(true, ("DMG" + lv_effectName + "Heroic:DamageAttempted" + IntToString(lp_reportPlayer)), 0.0);

        DataTableSetFixed(true, ("DMG" + lv_effectName + "Heroic:DamageDone" + IntToString(lp_reportPlayer)), 0.0);

        DataTableSetInt(true, ("DMG" + lv_effectName + ":EffectCount" + IntToString(lp_reportPlayer)), 0);

        DataTableSetFixed(true, ("DMG" + lv_effectName + ":DamageAttempted" + IntToString(lp_reportPlayer)), 0.0);

        DataTableSetFixed(true, ("DMG" + lv_effectName + ":DamageDone" + IntToString(lp_reportPlayer)), 0.0);

    }

    TriggerDebugOutput(7, StringExternal("Param/Value/lib_Sprt_9950C0AA"), false);

    auto98AE91C5_ae = DataTableGetInt(true, ("HLGStatTrackPlayer" + lv_reportPlayerAsStr + ":EffectInstanceCount"));

    lv_itEntry = 1;

    for ( ; ( (auto98AE91C5_ai >= 0 && lv_itEntry <= auto98AE91C5_ae) || (auto98AE91C5_ai < 0 && lv_itEntry >= auto98AE91C5_ae) ) ; lv_itEntry += auto98AE91C5_ai ) {

        lv_effectName = DataTableGetString(true, ("HLGStatTrackPlayer" + lv_reportPlayerAsStr + ":Effect" + IntToString(lv_itEntry)));

        if ((CatalogFieldValueGet(c_gameCatalogEffect, lv_effectName, "AmountScoreArray[" + IntToString(0) + "].Value", c_playerAny) == "")) {

            continue;

        }



        TextExpressionSetToken("Param/Expression/lib_Sprt_8634C21F", "D", StringToText(lv_effectName));

        TextExpressionSetToken("Param/Expression/lib_Sprt_8634C21F", "A", IntToText(DataTableGetInt(true, ("HLG" + lv_effectName + "Heroic:EffectCount" + IntToString(lp_reportPlayer)))));

        TextExpressionSetToken("Param/Expression/lib_Sprt_8634C21F", "B", FixedToText(DataTableGetFixed(true, ("HLG" + lv_effectName + "Heroic:HealingDone" + IntToString(lp_reportPlayer))), 0));

        TextExpressionSetToken("Param/Expression/lib_Sprt_8634C21F", "E", IntToText(DataTableGetInt(true, ("HLG" + lv_effectName + ":EffectCount" + IntToString(lp_reportPlayer)))));

        TextExpressionSetToken("Param/Expression/lib_Sprt_8634C21F", "F", FixedToText(DataTableGetFixed(true, ("HLG" + lv_effectName + ":HealingDone" + IntToString(lp_reportPlayer))), 0));

        TriggerDebugOutput(7, TextExpressionAssemble("Param/Expression/lib_Sprt_8634C21F"), false);

        DataTableSetString(true, ("HLGStatTrackPlayer" + lv_reportPlayerAsStr + ":Effect" + IntToString(lv_itEntry)), "");

        DataTableSetInt(true, ("HLG" + lv_effectName + "Heroic:EffectCount" + IntToString(lp_reportPlayer)), 0);

        DataTableSetFixed(true, ("HLG" + lv_effectName + "Heroic:HealingDone" + IntToString(lp_reportPlayer)), 0.0);

        DataTableSetInt(true, ("HLG" + lv_effectName + ":EffectCount" + IntToString(lp_reportPlayer)), 0);

        DataTableSetFixed(true, ("HLG" + lv_effectName + ":HealingDone" + IntToString(lp_reportPlayer)), 0.0);

    }

    DataTableSetInt(true, ("DMGStatTrackPlayer" + lv_reportPlayerAsStr + ":EffectInstanceCount"), 0);

    DataTableSetInt(true, ("HLGStatTrackPlayer" + lv_reportPlayerAsStr + ":EffectInstanceCount"), 0);

    lv_talentTextLine = StringExternal("Param/Value/lib_Sprt_B1D004C9");

    lv_itTalent = 1;

    for ( ; ( (autoFCC81157_ai >= 0 && lv_itTalent <= autoFCC81157_ae) || (autoFCC81157_ai < 0 && lv_itTalent >= autoFCC81157_ae) ) ; lv_itTalent += autoFCC81157_ai ) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_E273B3DE", "A", IntToText(lv_itTalent));

        TextExpressionSetToken("Param/Expression/lib_Sprt_E273B3DE", "B", StringToText((libGame_gv_talents_TalentChoices[lp_reportPlayer][lv_itTalent].lv_talentData[libGame_gv_talents_TalentChoices[lp_reportPlayer][lv_itTalent].lv_selection].lv_talentCatalogLink)));

        lv_talentTextLine = (lv_talentTextLine + TextExpressionAssemble("Param/Expression/lib_Sprt_E273B3DE"));

    }

    TextExpressionSetToken("Param/Expression/lib_Sprt_0F17B510", "A", IntToText((libCore_gv_talents_MaxTiers_C + 1)));

    lv_talentTextLine = (lv_talentTextLine + TextExpressionAssemble("Param/Expression/lib_Sprt_0F17B510"));

    TextExpressionSetToken("Param/Expression/lib_Sprt_BBA46ABE", "A", FixedToText(PlayerScoreValueGetAsFixed(lp_reportPlayer, "HeroDamage"), 0));

    TextExpressionSetToken("Param/Expression/lib_Sprt_BBA46ABE", "B", FixedToText(PlayerScoreValueGetAsFixed(lp_reportPlayer, "SiegeDamage"), 0));

    TriggerDebugOutput(7, TextExpressionAssemble("Param/Expression/lib_Sprt_BBA46ABE"), false);

    TriggerDebugOutput(7, lv_talentTextLine, false);

}



int libSprt_gf_DataMiningGetManaRegenSourceIndex (string lp_name) {

    // Variable Declarations

    int lv_i;



    // Automatic Variable Declarations

    const int auto85B681AE_ae = libSprt_gv_dataMiningMaxNumberOfDifferentManaRegenSources;

    const int auto85B681AE_ai = 1;



    // Variable Initialization



    // Implementation

    lv_i = 1;

    for ( ; ( (auto85B681AE_ai >= 0 && lv_i <= auto85B681AE_ae) || (auto85B681AE_ai < 0 && lv_i >= auto85B681AE_ae) ) ; lv_i += auto85B681AE_ai ) {

        if ((libSprt_gv_dataMiningManaRegenSourceNames[lv_i] == lp_name)) {

            return lv_i;

        }



        if ((libSprt_gv_dataMiningManaRegenSourceNames[lv_i] == "")) {

            libSprt_gv_dataMiningManaRegenSourceNames[lv_i] = lp_name;

            return lv_i;

        }



    }

    return 0;

}



void libSprt_gf_DataMiningPeriodicDataSend () {

    // Variable Declarations

    int lv_itTeam;

    int lv_itPlayer;

    int lv_itTown;

    int lv_itStructure;

    int lv_player;

    unit lv_heroUnit;

    unit lv_structureUnit;

    fixed lv_structureHPPercent;



    // Automatic Variable Declarations

    const int auto9AD7948B_ae = libCore_gv_bALMaxTeams;

    const int auto9AD7948B_ai = 1;



    // Variable Initialization



    // Implementation

    lv_itTeam = 1;

    for ( ; ( (auto9AD7948B_ai >= 0 && lv_itTeam <= auto9AD7948B_ae) || (auto9AD7948B_ai < 0 && lv_itTeam >= auto9AD7948B_ae) ) ; lv_itTeam += auto9AD7948B_ai ) {

        lv_player = PlayerGroupPlayer(libGame_gv_teams[lv_itTeam].lv_teamPlayerGroupNoNPCPlayers, 1);

        if ((lv_player > 0) && (lv_player <= libCore_gv_bALMaxPlayers)) {

            StatEventCreate("PeriodicXPBreakdown");

            StatEventAddDataFixed(StatEventLastCreated(), "GameTime", TimerGetElapsed(libGame_gv_gameTimer));

            StatEventAddDataFixed(StatEventLastCreated(), "PreviousGameTime", libSprt_gv_dataMiningTimeStampofLastPeriodicTransmit);

            StatEventAddDataInt(StatEventLastCreated(), "Team", lv_itTeam);

            StatEventAddDataInt(StatEventLastCreated(), "TeamLevel", libGame_gv_teams[lv_itTeam].lv_teamLevel);

            StatEventAddDataFixed(StatEventLastCreated(), "MinionXP", libGame_gv_players[lv_player].lv_xPRecievedFromMinions);

            StatEventAddDataFixed(StatEventLastCreated(), "CreepXP", libGame_gv_players[lv_player].lv_xPRecievedFromCreeps);

            StatEventAddDataFixed(StatEventLastCreated(), "StructureXP", libGame_gv_players[lv_player].lv_xPRecievedFromStructures);

            StatEventAddDataFixed(StatEventLastCreated(), "HeroXP", libGame_gv_players[lv_player].lv_xPRecievedFromHeroes);

            StatEventAddDataFixed(StatEventLastCreated(), "TrickleXP", libGame_gv_players[lv_player].lv_xPRecievedFromTrickle);

            StatEventSend(StatEventLastCreated());

        }



    }

    libSprt_gv_dataMiningTimeStampofLastPeriodicTransmit = TimerGetElapsed(libGame_gv_gameTimer);

}



void libSprt_gf_DataMiningLogManaRegenForPlayer (int lp_player, string lp_regenSourceName, fixed lp_amount) {

    // Automatic Variable Declarations

    // Implementation

    libSprt_gv_dataMining_PlayerData[lp_player].lv_manaRegenAmounts[libSprt_gf_DataMiningGetManaRegenSourceIndex(lp_regenSourceName)] += lp_amount;

}



void libSprt_gf_DataMiningTurnDataMiningTriggersOnOff (bool lp_onOff) {

    // Automatic Variable Declarations

    // Implementation

    TriggerEnable(libSprt_gt_DataMiningListenForRegenGlobes, lp_onOff);

    if ((lp_onOff == true)) {

        TimerStart(libSprt_gv_dataMiningPeriodicTimer, libSprt_gv_dataMiningPeriodicSendPeriod, false, c_timeGame);

    }



    TriggerEnable(libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger, lp_onOff);

}



void libSprt_gf_DataMiningSendStartGameEvents () {

    // Variable Declarations

    int lv_i;

    int lv_k;

    string lv_controller;

    string lv_handle;



    // Automatic Variable Declarations

    const int autoBAAD8CF8_ae = libCore_gv_bALMaxPlayers;

    const int autoBAAD8CF8_ai = 1;

    int auto3E9EF2A0_val;

    int autoB5E0751A_ae;

    const int autoB5E0751A_ai = 1;

    int auto60B8D5BE_ae;

    const int auto60B8D5BE_ai = 1;

    int autoF8A3E2EA_ae;

    const int autoF8A3E2EA_ai = 1;



    // Variable Initialization

    lv_controller = "";

    lv_handle = "";



    // Implementation

    StatEventCreate("GameStart");

    StatEventAddDataFixed(StatEventLastCreated(), "MapSizeX", PointGetX(RegionGetBoundsMax(RegionEntireMap())));

    StatEventAddDataFixed(StatEventLastCreated(), "MapSizeY", PointGetY(RegionGetBoundsMax(RegionEntireMap())));

    StatEventSend(StatEventLastCreated());

    lv_i = 1;

    for ( ; ( (autoBAAD8CF8_ai >= 0 && lv_i <= autoBAAD8CF8_ae) || (autoBAAD8CF8_ai < 0 && lv_i >= autoBAAD8CF8_ae) ) ; lv_i += autoBAAD8CF8_ai ) {

        auto3E9EF2A0_val = PlayerType(lv_i);

        if (auto3E9EF2A0_val == c_playerTypeNone) {

            lv_controller = "None";

        }

        else if (auto3E9EF2A0_val == c_playerTypeUser) {

            lv_controller = "User";

        }

        else if (auto3E9EF2A0_val == c_playerTypeComputer) {

            lv_controller = "Computer";

        }

        else {

        }

        StatEventCreate("PlayerInit");

        StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_i);

        StatEventAddDataInt(StatEventLastCreated(), "Team", libGame_gf_TeamNumberOfPlayer(lv_i));

        StatEventAddDataString(StatEventLastCreated(), "Controller", lv_controller);

        if ((PlayerType(lv_i) == c_playerTypeUser)) {

            lv_handle = PlayerHandle(lv_i);

            if ((lv_handle != "")) {

                StatEventAddDataString(StatEventLastCreated(), "ToonHandle", lv_handle);

            }



        }



        StatEventSend(StatEventLastCreated());

    }

    autoB5E0751A_ae = libGame_gv_townTownCount;

    lv_i = 1;

    for ( ; ( (autoB5E0751A_ai >= 0 && lv_i <= autoB5E0751A_ae) || (autoB5E0751A_ai < 0 && lv_i >= autoB5E0751A_ae) ) ; lv_i += autoB5E0751A_ai ) {

        auto60B8D5BE_ae = libGame_gv_townTownData[lv_i].lv_structureCount;

        lv_k = 1;

        for ( ; ( (auto60B8D5BE_ai >= 0 && lv_k <= auto60B8D5BE_ae) || (auto60B8D5BE_ai < 0 && lv_k >= auto60B8D5BE_ae) ) ; lv_k += auto60B8D5BE_ai ) {

            if ((libGame_gv_townTownData[lv_i].lv_structureTypes[lv_k] == libGame_ge_TownStructureTypes_TownHall)) {

                StatEventCreate("TownStructureInit");

                StatEventAddDataInt(StatEventLastCreated(), "TownID", lv_i);

                StatEventAddDataInt(StatEventLastCreated(), "Team", libGame_gf_TeamNumberOfPlayer(libGame_gv_townTownData[lv_i].lv_owner));

                StatEventAddDataInt(StatEventLastCreated(), "Lane", libGame_gv_townTownData[lv_i].lv_lane);

                StatEventAddDataFixed(StatEventLastCreated(), "PositionX", PointGetX(libGame_gv_townTownData[lv_i].lv_structureSpawnPoints[lv_k]));

                StatEventAddDataFixed(StatEventLastCreated(), "PositionY", PointGetY(libGame_gv_townTownData[lv_i].lv_structureSpawnPoints[lv_k]));

                StatEventSend(StatEventLastCreated());

            }



        }

    }

    autoF8A3E2EA_ae = libMapM_gv_jungleNumberOfCreepCamps;

    lv_i = 1;

    for ( ; ( (autoF8A3E2EA_ai >= 0 && lv_i <= autoF8A3E2EA_ae) || (autoF8A3E2EA_ai < 0 && lv_i >= autoF8A3E2EA_ae) ) ; lv_i += autoF8A3E2EA_ai ) {

        StatEventCreate("JungleCampInit");

        StatEventAddDataInt(StatEventLastCreated(), "CampID", lv_i);

        StatEventAddDataFixed(StatEventLastCreated(), "PositionX", PointGetX(libMapM_gv_jungleCreepCamps[lv_i].lv_mapDataCampCaptainSpawnPoint));

        StatEventAddDataFixed(StatEventLastCreated(), "PositionY", PointGetY(libMapM_gv_jungleCreepCamps[lv_i].lv_mapDataCampCaptainSpawnPoint));

        StatEventSend(StatEventLastCreated());

    }

}



void libSprt_gf_DataMiningSendEndOfGameDigests (int lp_team) {

    // Variable Declarations

    int lv_player;

    int lv_source;

    string lv_sourceName;

    int lv_itTalentTier;



    // Automatic Variable Declarations

    const int auto01159F25_ae = libCore_gv_bALMaxPlayers;

    const int auto01159F25_ai = 1;

    const int autoD3BAC227_ae = 7;

    const int autoD3BAC227_ai = 1;



    // Variable Initialization

    lv_sourceName = "";



    // Implementation

    lv_player = 1;

    for ( ; ( (auto01159F25_ai >= 0 && lv_player <= auto01159F25_ae) || (auto01159F25_ai < 0 && lv_player >= auto01159F25_ae) ) ; lv_player += auto01159F25_ai ) {

        if ((PlayerStatus(lv_player) == c_playerStatusUnused)) {

            continue;

        }



        StatEventCreate("EndOfGameXPBreakdown");

        StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_player);

        StatEventAddDataFixed(StatEventLastCreated(), "MinionXP", libGame_gv_players[lv_player].lv_xPRecievedFromMinions);

        StatEventAddDataFixed(StatEventLastCreated(), "CreepXP", libGame_gv_players[lv_player].lv_xPRecievedFromCreeps);

        StatEventAddDataFixed(StatEventLastCreated(), "StructureXP", libGame_gv_players[lv_player].lv_xPRecievedFromStructures);

        StatEventAddDataFixed(StatEventLastCreated(), "HeroXP", libGame_gv_players[lv_player].lv_xPRecievedFromHeroes);

        StatEventAddDataFixed(StatEventLastCreated(), "TrickleXP", libGame_gv_players[lv_player].lv_xPRecievedFromTrickle);

        StatEventSend(StatEventLastCreated());

        StatEventCreate("EndOfGameTimeSpentDead");

        StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_player);

        StatEventAddDataFixed(StatEventLastCreated(), "Time", libGame_gv_players[lv_player].lv_timeSpentDead);

        StatEventSend(StatEventLastCreated());

        if ((PlayerHasTalent(lv_player, "GenericTalentRegenerationMaster") == true)) {

            StatEventCreate("EndOfGameRegenMasterStacks");

            StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_player);

            StatEventAddDataString(StatEventLastCreated(), "Hero", (UnitGetType(libGame_gv_players[lv_player].lv_heroUnit)));

            StatEventAddDataInt(StatEventLastCreated(), "Stack Count", UnitBehaviorCount(libGame_gv_players[lv_player].lv_heroUnit, "RegenerationMaster"));

            StatEventSend(StatEventLastCreated());

        }



        if ((PlayerHasTalent(lv_player, "GenericTalentSeasonedMarksman") == true)) {

            StatEventCreate("EndOfGameMarksmanStacks");

            StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_player);

            StatEventAddDataString(StatEventLastCreated(), "Hero", (UnitGetType(libGame_gv_players[lv_player].lv_heroUnit)));

            StatEventAddDataInt(StatEventLastCreated(), "Stack Count", FixedToInt(UnitGetTokenCount(libGame_gv_players[lv_player].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogBehavior, "TalentSeasonedMarksmanTokenCounter", "TokenId", c_playerAny))));

            StatEventSend(StatEventLastCreated());

        }



        StatEventCreate("EndOfGameTalentChoices");

        StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_player);

        StatEventAddDataString(StatEventLastCreated(), "Hero", (UnitGetType(libGame_gv_players[lv_player].lv_heroUnit)));

        StatEventAddDataInt(StatEventLastCreated(), "Level", libGame_gv_teams[libGame_gf_TeamNumberOfPlayer(lv_player)].lv_teamLevel);

        if ((libGame_gf_TeamNumberOfPlayer(lv_player) == lp_team)) {

            StatEventAddDataString(StatEventLastCreated(), "Win/Loss", "Win");

        }

        else {

            StatEventAddDataString(StatEventLastCreated(), "Win/Loss", "Loss");

        }

        StatEventAddDataString(StatEventLastCreated(), "Map", libCore_gv_mAPMapStringID);

        lv_itTalentTier = 1;

        for ( ; ( (autoD3BAC227_ai >= 0 && lv_itTalentTier <= autoD3BAC227_ae) || (autoD3BAC227_ai < 0 && lv_itTalentTier >= autoD3BAC227_ae) ) ; lv_itTalentTier += autoD3BAC227_ai ) {

            if ((libGame_gv_talents_TalentChoices[lv_player][lv_itTalentTier].lv_talentData[libGame_gv_talents_TalentChoices[lv_player][lv_itTalentTier].lv_selection].lv_talentCatalogLink != null)) {

                StatEventAddDataString(StatEventLastCreated(), ("Tier " + IntToString(lv_itTalentTier) + " Choice"), (libGame_gv_talents_TalentChoices[lv_player][lv_itTalentTier].lv_talentData[libGame_gv_talents_TalentChoices[lv_player][lv_itTalentTier].lv_selection].lv_talentCatalogLink));

            }

            else {

                break;

            }

        }

        StatEventSend(StatEventLastCreated());

    }

    libSprt_gf_DataMiningTurnDataMiningTriggersOnOff(false);

}



void libSprt_gf_SetHeroMasteryRingLevel (int lp_player) {

    // Variable Declarations

    int lv_i;

    string lv_playerHero;

    int lv_playerMasteryLevel;

    string lv_heroCatalogID;

    string lv_masteryRingString;

    int lv_iteratorString;

    string lv_combinedHeroString;

    string lv_combinedRewardArrayStringValue;

    int lv_lastSuccessfulUpgradeLevel;



    // Automatic Variable Declarations

    int auto311B52FA_ae;

    const int auto311B52FA_ai = 1;

    unitgroup auto31D416DD_g;

    int auto31D416DD_u;

    unit auto31D416DD_var;



    // Variable Initialization

    lv_playerHero = PlayerHero(lp_player);

    lv_playerMasteryLevel = PlayerHeroMasteryTier(lp_player, PlayerHero(lp_player));

    lv_heroCatalogID = (lv_playerHero);

    lv_masteryRingString = "MasteryRing";

    lv_iteratorString = 1;

    lv_combinedHeroString = "";

    lv_combinedRewardArrayStringValue = "";



    // Implementation

    auto311B52FA_ae = libSprt_gv_heroMasteryRingsMaxRank;

    lv_i = 1;

    for ( ; ( (auto311B52FA_ai >= 0 && lv_i <= auto311B52FA_ae) || (auto311B52FA_ai < 0 && lv_i >= auto311B52FA_ae) ) ; lv_i += auto311B52FA_ai ) {

        lv_combinedHeroString = (lv_heroCatalogID + lv_masteryRingString + IntToString(lv_iteratorString));

        lv_combinedRewardArrayStringValue = CatalogFieldValueGet(c_gameCatalogHero, lv_playerHero, "HeroMasteryRingArray[" + IntToString(lv_iteratorString) + "]", lp_player);

        if ((lv_playerMasteryLevel >= lv_iteratorString) && (PlayerHasReward(lp_player, (lv_combinedRewardArrayStringValue)) == true)) {

            lv_lastSuccessfulUpgradeLevel = lv_iteratorString;

            lv_iteratorString += 1;

            if ((lv_iteratorString > libSprt_gv_heroMasteryRingsMaxRank)) {

                lv_iteratorString = libSprt_gv_heroMasteryRingsMaxRank;

                break;

            }



        }

        else {

            break;

        }

    }

    libNtve_gf_SetUpgradeLevelForPlayer(lp_player, "HeroRingMasteryUpgrade", lv_lastSuccessfulUpgradeLevel);

    if (((lv_playerHero == "Cho") || (lv_playerHero == "Gall"))) {

        if ((lv_lastSuccessfulUpgradeLevel > libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lp_player)].lv_pairedHighestHeroRingMasteryLevel)) {

            libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lp_player)].lv_pairedHighestHeroRingMasteryLevel = lv_lastSuccessfulUpgradeLevel;

        }



    }

    else {

        auto31D416DD_g = libGame_gv_players[lp_player].lv_heroUnitGroup;

        auto31D416DD_u = UnitGroupCount(auto31D416DD_g, c_unitCountAll);

        for (;; auto31D416DD_u -= 1) {

            auto31D416DD_var = UnitGroupUnitFromEnd(auto31D416DD_g, auto31D416DD_u);

            if (auto31D416DD_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(auto31D416DD_var, "Signal MasteryRingCreation");

        }

    }

}



void libSprt_gf_ChoGallHeroMasteryRing (int lp_player) {

    // Automatic Variable Declarations

    unitgroup autoE98F73C3_g;

    int autoE98F73C3_u;

    unit autoE98F73C3_var;



    // Implementation

    libNtve_gf_SetUpgradeLevelForPlayer(libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lp_player)].lv_choPlayer, "HeroRingMasteryUpgrade", libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lp_player)].lv_pairedHighestHeroRingMasteryLevel);

    autoE98F73C3_g = libGame_gv_players[libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lp_player)].lv_choPlayer].lv_heroUnitGroup;

    autoE98F73C3_u = UnitGroupCount(autoE98F73C3_g, c_unitCountAll);

    for (;; autoE98F73C3_u -= 1) {

        autoE98F73C3_var = UnitGroupUnitFromEnd(autoE98F73C3_g, autoE98F73C3_u);

        if (autoE98F73C3_var == null) { break; }

        libNtve_gf_SendActorMessageToUnit(autoE98F73C3_var, "Signal MasteryRingCreation");

    }

}



void libSprt_gf_QACheatsUIInit () {

    int init_i;



    // Variable Declarations

    int lv_i;

    int lv_testCount;

    int lv_itPlayer;

    int[6] lv_panels;

    int lv_currentPanelLayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_testCount = 30;

    for (init_i = 0; init_i <= 5; init_i += 1) {

        lv_panels[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogCreate(300, 860, c_anchorTopRight, 100, 50, true);

    libSprt_gv_qACheatsControlsPanel.lv_mainDialog = DialogLastCreated();

    DialogSetImage(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, "Assets\\Textures\\storm_ui_store_gradientbackground_new.dds");

    libNtve_gf_CreateDialogItemLabel(DialogLastCreated(), 175, 25, c_anchorTop, 50, 0, StringExternal("Param/Value/lib_Sprt_3EA40164"), Color(100,100,100), false, 2.0);

    libNtve_gf_CreateDialogItemButton(DialogLastCreated(), 35, 35, c_anchorTopRight, 5, 5, StringToText(""), StringExternal("Param/Value/lib_Sprt_4377DBE5"), "");

    libSprt_gv_qACheatsControlsPanel.lv_closeButton = DialogControlLastCreated();

    libSprt_gf_QACheatsCompileBehaviors();

    libSprt_gf_QACheatsCompileSpawnUnits();

    libSprt_gf_QACheatsPopulateBehaviorPulldown();

    libSprt_gf_QACheatsAddBehaviorButtons();

    libSprt_gf_QACheatsAddToggleCheckboxes();

    libSprt_gf_QACheatsAddSpeedControls();

    libSprt_gf_QACheatsPopulateSpawnUnitsPulldown();

    libSprt_gf_QACheatsAddTeamCheckboxes();

    libSprt_gf_QACheatsAddUnitControlButtons();

    libSprt_gf_QACheatsAddCameraControls();

    libSprt_gf_QACheatsAddDebugRespawnButton();

    libSprt_gf_QACheatsCompileSpawnItems();

    libSprt_gf_QACheatsPopulateSpawnItemsPulldown();

    libSprt_gf_QACheatsAddSpawnItemButton();

    libSprt_gf_QACheatsAddStructureControlsButtons();

}



void libSprt_gf_QACheatsPopulateBehaviorPulldown () {

    int init_i;



    // Variable Declarations

    int lv_i;

    int lv_behaviorCount;

    int lv_itPlayer;

    int[6] lv_panels;

    int lv_currentPanelLayer;



    // Automatic Variable Declarations

    int auto0999BBE2_ae;

    const int auto0999BBE2_ai = 1;



    // Variable Initialization

    lv_behaviorCount = 30;

    for (init_i = 0; init_i <= 5; init_i += 1) {

        lv_panels[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogControlCreate(DialogLastCreated(), c_triggerControlTypePulldown);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 25, 40);

    auto0999BBE2_ae = lv_behaviorCount;

    lv_i = 1;

    for ( ; ( (auto0999BBE2_ai >= 0 && lv_i <= auto0999BBE2_ae) || (auto0999BBE2_ai < 0 && lv_i >= auto0999BBE2_ae) ) ; lv_i += auto0999BBE2_ai ) {

        if ((libSprt_gv_compiledBehaviorList[lv_i] != null)) {

            DialogControlAddItem(DialogControlLastCreated(), PlayerGroupAll(), StringToText(libSprt_gv_compiledBehaviorList[lv_i]));

        }



    }

    DialogControlSelectItem(DialogControlLastCreated(), PlayerGroupAll(), 1);

    libSprt_gv_qACheatsControlsPanel.lv_behaviorListPulldown = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddBehaviorButtons () {

    // Variable Declarations

    int lv_buttonX;

    int lv_buttonY;

    int lv_offsetX;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_buttonY = 75;

    lv_offsetX = 90;



    // Implementation

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_B079FB80"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_CFB7F160"), PlayerGroupAll());

    lv_buttonX = (lv_buttonX + lv_offsetX);

    libSprt_gv_qACheatsControlsPanel.lv_behaviorApplyButton = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_A4C4F695"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_0CB66395"), PlayerGroupAll());

    lv_buttonX = (lv_buttonX + lv_offsetX);

    libSprt_gv_qACheatsControlsPanel.lv_behaviorRemoveButton = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_E7170FBB"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_9485143B"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_behaviorCleanseButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddToggleCheckboxes () {

    // Variable Declarations

    int lv_checkboxStartX;

    int lv_checkboxStartY;

    int lv_checkboxX;

    int lv_checkboxY;

    int lv_offsetX;

    int lv_offsetY;

    int lv_labelOffset;

    int lv_labelStartX;

    int lv_labelStartY;

    int lv_labelX;

    int lv_labelY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_checkboxStartX = 15;

    lv_checkboxStartY = 150;

    lv_checkboxX = lv_checkboxStartX;

    lv_checkboxY = lv_checkboxStartY;

    lv_offsetX = 85;

    lv_offsetY = 25;

    lv_labelOffset = 30;

    lv_labelStartX = (lv_checkboxStartX + lv_labelOffset);

    lv_labelStartY = lv_checkboxStartY;

    lv_labelX = lv_labelStartX;

    lv_labelY = lv_labelStartY;



    // Implementation

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_99E675E7"), false);

    libSprt_gv_qACheatsControlsPanel.lv_alliedControlCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_3C851DAE"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_E24E1AD2"), false);

    libSprt_gv_qACheatsControlsPanel.lv_toggleSelectionCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_54B5AAA1"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_BDF321A4"), false);

    libSprt_gv_qACheatsControlsPanel.lv_showMapCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_90E482DB"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_labelX = (lv_labelStartX + lv_offsetX);

    lv_labelY = lv_labelStartY;

    lv_checkboxX = (lv_checkboxStartX + lv_offsetX);

    lv_checkboxY = lv_checkboxStartY;

    lv_checkboxStartX = lv_checkboxX;

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_C9702EBD"), false);

    libSprt_gv_qACheatsControlsPanel.lv_gridCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_AAAB7B41"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_CEDD647E"), false);

    libSprt_gv_qACheatsControlsPanel.lv_tVECheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_F27271C6"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_DFE5FD64"), false);

    libSprt_gv_qACheatsControlsPanel.lv_visionCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_310E7505"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_labelX = (lv_labelX + lv_offsetX);

    lv_labelY = lv_labelStartY;

    lv_checkboxX = (lv_checkboxStartX + lv_offsetX);

    lv_checkboxY = lv_checkboxStartY;

    lv_checkboxStartX = lv_checkboxX;

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_3620F2BF"), false);

    libSprt_gv_qACheatsControlsPanel.lv_freeCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_D115F208"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_BA98993A"), false);

    libSprt_gv_qACheatsControlsPanel.lv_cooldownsCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_7F25530D"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_B370BB3D"), false);

    libSprt_gv_qACheatsControlsPanel.lv_toggleWeaponsCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_7DFFE6DD"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxY = (lv_checkboxY + lv_offsetY);

    lv_labelY = (lv_labelY + lv_offsetY);

}



void libSprt_gf_QACheatsAddSpeedControls () {

    // Variable Declarations

    int lv_textBoxX;

    int lv_textBoxY;

    int lv_offsetX;

    int lv_offsetY;

    int lv_buttonX;

    int lv_buttonY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_textBoxX = 25;

    lv_textBoxY = 245;

    lv_offsetX = 60;

    lv_offsetY = -18;

    lv_buttonX = (lv_textBoxX + lv_offsetX);

    lv_buttonY = (lv_textBoxY + lv_offsetY);



    // Implementation

    DialogControlCreate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeEditBox);

    libSprt_gv_qACheatsControlsPanel.lv_speedCountEditbox = DialogControlLastCreated();

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 70, 40);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_textBoxX, lv_textBoxY);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 165, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_F173037D"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_15C84FDB"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_executeSpeedButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsPopulateSpawnUnitsPulldown () {

    int init_i;



    // Variable Declarations

    int lv_i;

    int lv_spawnUnitsCount;

    int lv_itPlayer;

    int[6] lv_panels;

    int lv_currentPanelLayer;



    // Automatic Variable Declarations

    int autoE6F0D871_ae;

    const int autoE6F0D871_ai = 1;



    // Variable Initialization

    lv_spawnUnitsCount = 30;

    for (init_i = 0; init_i <= 5; init_i += 1) {

        lv_panels[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogControlCreate(DialogLastCreated(), c_triggerControlTypePulldown);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 25, 300);

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_57EEC39B"), PlayerGroupAll());

    autoE6F0D871_ae = lv_spawnUnitsCount;

    lv_i = 1;

    for ( ; ( (autoE6F0D871_ai >= 0 && lv_i <= autoE6F0D871_ae) || (autoE6F0D871_ai < 0 && lv_i >= autoE6F0D871_ae) ) ; lv_i += autoE6F0D871_ai ) {

        if ((libSprt_gv_qACheatsCompiledSpawnUnitsList[lv_i] != null)) {

            DialogControlAddItem(DialogControlLastCreated(), PlayerGroupAll(), StringToText(libSprt_gv_qACheatsCompiledSpawnUnitsList[lv_i]));

        }



    }

    DialogControlSelectItem(DialogControlLastCreated(), PlayerGroupAll(), 1);

    libSprt_gv_qACheatsControlsPanel.lv_spawnUnitListPulldown = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddTeamCheckboxes () {

    // Variable Declarations

    int lv_checkboxX;

    int lv_checkboxY;

    int lv_offsetX;

    int lv_offsetY;

    int lv_labelX;

    int lv_labelY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_checkboxX = 60;

    lv_checkboxY = 355;

    lv_offsetX = 110;

    lv_labelX = 85;

    lv_labelY = 355;



    // Implementation

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_16505168"), false);

    libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_9AD9AA1D"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxX = (lv_checkboxX + lv_offsetX);

    lv_labelX = (lv_labelX + lv_offsetX);

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_242FED14"), false);

    libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_544DEB9B"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

    lv_checkboxX = (lv_checkboxX + lv_offsetX);

    lv_labelX = (lv_labelX + lv_offsetX);

}



void libSprt_gf_QACheatsAddUnitControlButtons () {

    // Variable Declarations

    int lv_buttonStartX;

    int lv_buttonStartY;

    int lv_buttonX;

    int lv_buttonY;

    int lv_offsetX;

    int lv_offsetY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_buttonStartX = 25;

    lv_buttonStartY = 370;

    lv_buttonX = lv_buttonStartX;

    lv_buttonY = lv_buttonStartY;

    lv_offsetX = 115;

    lv_offsetY = 40;



    // Implementation

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_A329D9C9"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_spawnUnitButton = DialogControlLastCreated();

    lv_buttonY = (lv_buttonY + lv_offsetY);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_C4AA4C9B"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_debugKillButton = DialogControlLastCreated();

    lv_buttonY = (lv_buttonY + lv_offsetY);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 240, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_5F84508B"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_refreshCooldownsButton = DialogControlLastCreated();

    lv_buttonX = (lv_buttonX + lv_offsetX);

    lv_buttonY = lv_buttonStartY;

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_CE8CB7A7"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_refreshUnitButton = DialogControlLastCreated();

    lv_buttonY = (lv_buttonY + lv_offsetY);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 125, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_F01B0BAE"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_moveUnitButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddCameraControls () {

    // Variable Declarations

    int lv_textBoxX;

    int lv_textBoxY;

    int lv_buttonOffsetX;

    int lv_buttonOffsetY;

    int lv_buttonX;

    int lv_buttonY;

    int lv_checkboxOffsetX;

    int lv_checkboxOffsetY;

    int lv_checkboxX;

    int lv_checkboxY;

    int lv_labelOffsetX;

    int lv_labelOffsetY;

    int lv_labelX;

    int lv_labelY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_textBoxX = 25;

    lv_textBoxY = 525;

    lv_buttonOffsetX = 50;

    lv_buttonOffsetY = -18;

    lv_buttonX = (lv_textBoxX + lv_buttonOffsetX);

    lv_buttonY = (lv_textBoxY + lv_buttonOffsetY);

    lv_checkboxOffsetX = 160;

    lv_checkboxOffsetY = 25;

    lv_checkboxX = (lv_buttonX + lv_checkboxOffsetX);

    lv_checkboxY = (lv_buttonY + lv_checkboxOffsetY);

    lv_labelOffsetX = 25;

    lv_labelX = (lv_checkboxX + lv_labelOffsetX);

    lv_labelY = (lv_checkboxY + lv_labelOffsetY);



    // Implementation

    DialogControlCreate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeEditBox);

    libSprt_gv_qACheatsControlsPanel.lv_cameraAngleEditbox = DialogControlLastCreated();

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 70, 40);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_textBoxX, lv_textBoxY);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 175, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_0214BBDC"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_E06E2001"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_setCameraAngleButton = DialogControlLastCreated();

    libNtve_gf_CreateDialogItemCheckBox(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, 25, 25, c_anchorTopLeft, lv_checkboxX, lv_checkboxY, StringExternal("Param/Value/lib_Sprt_7BD2E7F0"), false);

    libSprt_gv_qACheatsControlsPanel.lv_toggleDebugCameraCheckbox = DialogControlLastCreated();

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeLabel, "InputOptionsPanel/InputLabelTemplate");

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_6F9440D0"), PlayerGroupAll());

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_labelX, lv_labelY);

}



void libSprt_gf_QACheatsPopulateSpawnItemsPulldown () {

    int init_i;



    // Variable Declarations

    int lv_i;

    int lv_spawnItemsCount;

    int lv_itPlayer;

    int[6] lv_panels;

    int lv_currentPanelLayer;



    // Automatic Variable Declarations

    int autoF95D342D_ae;

    const int autoF95D342D_ai = 1;



    // Variable Initialization

    lv_spawnItemsCount = 5;

    for (init_i = 0; init_i <= 5; init_i += 1) {

        lv_panels[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogControlCreate(DialogLastCreated(), c_triggerControlTypePulldown);

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 190, 40);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 25, 580);

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_9747FD94"), PlayerGroupAll());

    autoF95D342D_ae = lv_spawnItemsCount;

    lv_i = 1;

    for ( ; ( (autoF95D342D_ai >= 0 && lv_i <= autoF95D342D_ae) || (autoF95D342D_ai < 0 && lv_i >= autoF95D342D_ae) ) ; lv_i += autoF95D342D_ai ) {

        if ((libSprt_gv_qACheatsCompiledSpawnItemsList[lv_i] != null)) {

            DialogControlAddItem(DialogControlLastCreated(), PlayerGroupAll(), StringToText(libSprt_gv_qACheatsCompiledSpawnItemsList[lv_i]));

        }



    }

    DialogControlSelectItem(DialogControlLastCreated(), PlayerGroupAll(), 1);

    libSprt_gv_qACheatsControlsPanel.lv_spawnItemListPulldown = DialogControlLastCreated();

    DialogControlCreate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeEditBox);

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 70, 40);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 210, 580);

    libSprt_gv_qACheatsControlsPanel.lv_itemCountEditbox = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddSpawnItemButton () {

    // Automatic Variable Declarations

    // Implementation

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 250, 75);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 25, 605);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_85C18D61"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_503583C8"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_spawnItemButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddStructureControlsButtons () {

    // Variable Declarations

    int lv_buttonStartX;

    int lv_buttonStartY;

    int lv_buttonX;

    int lv_buttonY;

    int lv_offsetX;

    int lv_offsetY;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_buttonStartX = 25;

    lv_buttonStartY = 655;

    lv_buttonX = lv_buttonStartX;

    lv_buttonY = lv_buttonStartY;

    lv_offsetX = 115;

    lv_offsetY = 40;



    // Implementation

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 150, 125);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_F4A81FFD"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_respawnStructuresButton = DialogControlLastCreated();

    lv_buttonX = (lv_buttonX + lv_offsetX);

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 150, 125);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, lv_buttonX, lv_buttonY);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_59E38088"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_killStructuresButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsAddDebugRespawnButton () {

    // Automatic Variable Declarations

    // Implementation

    DialogControlCreateFromTemplate(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, c_triggerControlTypeButton, "GameMenuDialog/GameMenuButtonTemplate/Button");

    DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), 250, 100);

    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, 25, 760);

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_0E09472A"), PlayerGroupAll());

    libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), StringExternal("Param/Value/lib_Sprt_4E1C1AFD"), PlayerGroupAll());

    libSprt_gv_qACheatsControlsPanel.lv_debugRespawnButton = DialogControlLastCreated();

}



void libSprt_gf_QACheatsCompileBehaviors () {

    // Automatic Variable Declarations

    // Implementation

    libSprt_gv_compiledBehaviorList[1] = "PermaSlow";

    libSprt_gv_compiledBehaviorList[2] = "PermaBlind";

    libSprt_gv_compiledBehaviorList[3] = "PermaRoot";

    libSprt_gv_compiledBehaviorList[4] = "PermaStun";

    libSprt_gv_compiledBehaviorList[5] = "PermaPoly";

    libSprt_gv_compiledBehaviorList[6] = "PermaSilence";

    libSprt_gv_compiledBehaviorList[7] = "PermaFear";

    libSprt_gv_compiledBehaviorList[8] = "PermaUnstoppable";

    libSprt_gv_compiledBehaviorList[9] = "PermaInvulnerable";

    libSprt_gv_compiledBehaviorList[10] = "PermaStasis";

    libSprt_gv_compiledBehaviorList[11] = "PermaSleep";

    libSprt_gv_compiledBehaviorList[12] = "PermaTimeStop";

    libSprt_gv_compiledBehaviorList[13] = "DisableWeaponsBehavior";

}



void libSprt_gf_QACheatsCompileSpawnUnits () {

    // Automatic Variable Declarations

    // Implementation

    libSprt_gv_qACheatsCompiledSpawnUnitsList[1] = "All Non-Structure Units";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[2] = "Minion";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[3] = "Summon (Locust)";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[4] = "Merc Defender";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[5] = "Summoner Merc";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[6] = "Boss";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[7] = "Monster";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[8] = "Tower";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[9] = "Fort";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[10] = "Keep";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[11] = "Vehicle";

    libSprt_gv_qACheatsCompiledSpawnUnitsList[12] = "TargetHeroDummyFreddie";

}



void libSprt_gf_QACheatsCompileSpawnItems () {

    // Automatic Variable Declarations

    // Implementation

    libSprt_gv_qACheatsCompiledSpawnItemsList[1] = "Regen Globe";

    libSprt_gv_qACheatsCompiledSpawnItemsList[2] = "Garden Seeds";

    libSprt_gv_qACheatsCompiledSpawnItemsList[3] = "Haunted Skulls";

    libSprt_gv_qACheatsCompiledSpawnItemsList[4] = "Doubloons";

    libSprt_gv_qACheatsCompiledSpawnItemsList[5] = "Experience Globe";

}



void libSprt_gf_QACheatsCleanseAllEffects () {

    // Variable Declarations

    int lv_i;



    // Automatic Variable Declarations

    const int auto91B7752C_ae = 13;

    const int auto91B7752C_ai = 1;



    // Variable Initialization

    lv_i = 1;



    // Implementation

    lv_i = 1;

    for ( ; ( (auto91B7752C_ai >= 0 && lv_i <= auto91B7752C_ae) || (auto91B7752C_ai < 0 && lv_i >= auto91B7752C_ae) ) ; lv_i += auto91B7752C_ai ) {

        UnitBehaviorRemove(libSprt_gv_qACheatsSelectedUnit, (libSprt_gv_compiledBehaviorList[lv_i]), 1);

    }

}



void libSprt_gf_DEBUGSoundRepeatRepeatSound () {

    // Automatic Variable Declarations

    // Implementation

    while ((libSprt_gv_soundRepeatActive == true)) {

        Wait(libSprt_gv_soundRepeatDelay, c_timeGame);

        if ((AbilityCommandGetAction(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0)) == c_cmdActionInstant)) {

            UnitIssueOrder(libSprt_gv_soundRepeatCasterUnit, Order(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0)), c_orderQueueReplace);

        }



        if ((AbilityCommandGetAction(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0)) == c_cmdActionTarget)) {

            if ((AbilityCommandGetAction(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0)) == c_cmdActionTarget)) {

                UnitIssueOrder(libSprt_gv_soundRepeatCasterUnit, OrderTargetingUnit(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0), libSprt_gv_soundRepeatTargetUnit), c_orderQueueReplace);

            }



            UnitIssueOrder(libSprt_gv_soundRepeatCasterUnit, OrderTargetingPoint(AbilityCommand(libSprt_gv_soundRepeatCurrentAbility, 0), libSprt_gv_soundRepeatTargetPoint), c_orderQueueReplace);

        }



    }

}



void libSprt_gf_DEBUGStartGame () {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return ;

    }



    TimerStart(libGame_gv_openTheGatesTimer, 0.0625, false, c_timeGame);

    TriggerStop(libGame_gt_AnnounceCountdown);

}



void libSprt_gf_DEBUGSpawnCreepCamps () {

    // Variable Declarations

    int lv_itCamp;



    // Automatic Variable Declarations

    int autoD6A4DA90_ae;

    const int autoD6A4DA90_ai = 1;



    // Variable Initialization



    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return ;

    }



    autoD6A4DA90_ae = libMapM_gv_jungleNumberOfCreepCamps;

    lv_itCamp = 1;

    for ( ; ( (autoD6A4DA90_ai >= 0 && lv_itCamp <= autoD6A4DA90_ae) || (autoD6A4DA90_ai < 0 && lv_itCamp >= autoD6A4DA90_ae) ) ; lv_itCamp += autoD6A4DA90_ai ) {

        if ((TimerGetRemaining(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepBirthTimer) > 0.0625)) {

            TimerStart(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepBirthTimer, 0.0625, false, c_timeGame);

            TimerStart(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepRespawnTimer, 0.0625, false, c_timeGame);

        }



    }

}



void libSprt_gf_DEBUGToggleSelection () {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return ;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelSelectionEnabledCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_selectionEnabledCheckbox, PlayerGroupAll(), false);

    if ((libSprt_gv_dEBUGSelectionEnabled == false)) {

        libSprt_gv_dEBUGSelectionEnabled = true;

        UISetDragSelectEnabled(PlayerGroupAll(), true);

        UISetSelectionTypeEnabled(PlayerGroupAll(), c_localSelectionTypeUnknown, true);

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_selectionEnabledCheckbox, true, PlayerGroupAll());

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_76A66534"), true);

    }

    else {

        libSprt_gv_dEBUGSelectionEnabled = false;

        UISetDragSelectEnabled(PlayerGroupAll(), false);

        UISetSelectionTypeEnabled(PlayerGroupAll(), c_localSelectionTypeUnknown, false);

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_selectionEnabledCheckbox, false, PlayerGroupAll());

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_991AD450"), true);

    }

    Wait(0.25, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelSelectionEnabledCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_selectionEnabledCheckbox, PlayerGroupAll(), true);

}



trigger auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_Trigger = null;



void libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection () {

    if (auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleSpawnatCameraorBaseSelection_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelSpawnAtBaseCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_spawnAtCameraCheckbox, PlayerGroupAll(), false);

    if ((libUIUI_gv_uIDebugPanelSpawnAtCamera == false)) {

        libUIUI_gv_uIDebugPanelSpawnAtCamera = true;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_spawnAtCameraCheckbox, true, PlayerGroupAll());

    }

    else {

        libUIUI_gv_uIDebugPanelSpawnAtCamera = false;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_spawnAtCameraCheckbox, false, PlayerGroupAll());

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelSpawnAtBaseCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_spawnAtCameraCheckbox, PlayerGroupAll(), true);

    return true;

}



trigger auto_libSprt_gf_DEBUGToggleMinionSpawning_Trigger = null;



void libSprt_gf_DEBUGToggleMinionSpawning () {

    if (auto_libSprt_gf_DEBUGToggleMinionSpawning_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleMinionSpawning_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleMinionSpawning_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleMinionSpawning_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleMinionSpawning_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelDisableMinionSpawningCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_disableMinionSpawningCheckbox, PlayerGroupAll(), false);

    if ((libUIUI_gv_uIDebugPanelDisableMinionSpawningToggle == true)) {

        libUIUI_gv_uIDebugPanelDisableMinionSpawningToggle = false;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_disableMinionSpawningCheckbox, false, PlayerGroupAll());

        TriggerExecute(libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn, true, false);

    }

    else {

        libUIUI_gv_uIDebugPanelDisableMinionSpawningToggle = true;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_disableMinionSpawningCheckbox, true, PlayerGroupAll());

        TriggerExecute(libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn, true, false);

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelDisableMinionSpawningCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_disableMinionSpawningCheckbox, PlayerGroupAll(), true);

    return true;

}



trigger auto_libSprt_gf_DEBUGToggleTrickleXP_Trigger = null;



void libSprt_gf_DEBUGToggleTrickleXP () {

    if (auto_libSprt_gf_DEBUGToggleTrickleXP_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleTrickleXP_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleTrickleXP_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleTrickleXP_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleTrickleXP_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelDisableTrickleXPCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_disableTrickleXPCheckbox, PlayerGroupAll(), false);

    libUIUI_gv_uIDebugPanelDisableTrickleXPToggle = !(libUIUI_gv_uIDebugPanelDisableTrickleXPToggle);

    TriggerExecute(libSprt_gt_DEBUGToggleXPTrickletogtrickle, true, false);

    if ((libUIUI_gv_uIDebugPanelDisableTrickleXPToggle == true)) {

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_disableTrickleXPCheckbox, true, PlayerGroupAll());

    }

    else {

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_disableTrickleXPCheckbox, false, PlayerGroupAll());

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelDisableTrickleXPCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_disableTrickleXPCheckbox, PlayerGroupAll(), true);

    return true;

}



trigger auto_libSprt_gf_DEBUGToggleCombatText_Trigger = null;



void libSprt_gf_DEBUGToggleCombatText () {

    if (auto_libSprt_gf_DEBUGToggleCombatText_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleCombatText_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleCombatText_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleCombatText_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleCombatText_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelCombatTextCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_floatingCombatTextCheckbox, PlayerGroupAll(), false);

    if ((libUIUI_gv_uIDebugPanelFloatingCombatTextToggle == true)) {

        libUIUI_gv_uIDebugPanelFloatingCombatTextToggle = false;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_floatingCombatTextCheckbox, false, PlayerGroupAll());

        TriggerExecute(libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext, true, false);

        DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, PlayerGroupAll(), false);

    }

    else {

        libUIUI_gv_uIDebugPanelFloatingCombatTextToggle = true;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_floatingCombatTextCheckbox, true, PlayerGroupAll());

        TriggerExecute(libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext, true, false);

        DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, PlayerGroupAll(), true);

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelCombatTextCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_floatingCombatTextCheckbox, PlayerGroupAll(), true);

    return true;

}



trigger auto_libSprt_gf_DEBUGToggleAllCombatText_Trigger = null;



void libSprt_gf_DEBUGToggleAllCombatText () {

    if (auto_libSprt_gf_DEBUGToggleAllCombatText_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleAllCombatText_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleAllCombatText_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleAllCombatText_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleAllCombatText_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelEnableAllCombatTextCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, PlayerGroupAll(), false);

    if ((libUIUI_gv_uIDebugPanelShowAllCombatText == true)) {

        libUIUI_gv_uIDebugPanelShowAllCombatText = false;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, false, PlayerGroupAll());

    }

    else {

        libUIUI_gv_uIDebugPanelShowAllCombatText = true;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, true, PlayerGroupAll());

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelEnableAllCombatTextCheckboxClicked, true);

    if ((libUIUI_gv_uIDebugPanelFloatingCombatTextToggle == true)) {

        DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_enableAllFloatingCombatTextCheckbox, PlayerGroupAll(), true);

    }



    return true;

}



trigger auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_Trigger = null;



void libSprt_gf_DEBUGToggleSavedHeroCheckbox () {

    if (auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_Trigger == null) {

        auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_Trigger = TriggerCreate("auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_TriggerFunc");

    }



    TriggerExecute(auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_Trigger, false, false);

}



bool auto_libSprt_gf_DEBUGToggleSavedHeroCheckbox_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    TriggerEnable(libUIUI_gt_UIDebugPanelSavedHeroCheckboxClicked, false);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_savedHeroCheckbox, PlayerGroupAll(), false);

    if ((libUIUI_gv_uIDebugPanelSavedHero == false)) {

        libUIUI_gv_uIDebugPanelSavedHero = true;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_savedHeroCheckbox, true, PlayerGroupAll());

    }

    else {

        libUIUI_gv_uIDebugPanelSavedHero = false;

        libNtve_gf_SetDialogItemChecked(libUIUI_gv_uIDebugPanel.lv_savedHeroCheckbox, false, PlayerGroupAll());

    }

    Wait(0.75, c_timeGame);

    TriggerEnable(libUIUI_gt_UIDebugPanelSavedHeroCheckboxClicked, true);

    DialogControlSetEnabled(libUIUI_gv_uIDebugPanel.lv_savedHeroCheckbox, PlayerGroupSingle(1), true);

    return true;

}



void libSprt_gf_DEBUGRefreshCooldownsforUnit (int lp_player, unit lp_unit) {

    // Variable Declarations

    int lv_itAbility;

    int lv_ownerofUnit;

    string lv_abilLink;

    string lv_cooldownLink;

    string lv_chargeLink;

    int lv_currentRank;

    unitgroup lv_unitGroup;



    // Automatic Variable Declarations

    int auto8A789BA6_ae;

    const int auto8A789BA6_ai = 1;



    // Variable Initialization

    lv_cooldownLink = "";

    lv_chargeLink = "";

    lv_unitGroup = UnitGroupEmpty();



    // Implementation

    lv_ownerofUnit = UnitGetOwner(lp_unit);

    auto8A789BA6_ae = UnitAbilityCount(lp_unit);

    lv_itAbility = 1;

    for ( ; ( (auto8A789BA6_ai >= 0 && lv_itAbility <= auto8A789BA6_ae) || (auto8A789BA6_ai < 0 && lv_itAbility >= auto8A789BA6_ae) ) ; lv_itAbility += auto8A789BA6_ai ) {

        lv_abilLink = UnitAbilityGet(lp_unit, lv_itAbility);

        if ((lv_abilLink != "") && (lv_abilLink != null) && ((AbilityClass(lv_abilLink) == c_classIdCAbilAugment) || (AbilityClass(lv_abilLink) == c_classIdCAbilBehavior) || (AbilityClass(lv_abilLink) == c_classIdCAbilEffectInstant) || (AbilityClass(lv_abilLink) == c_classIdCAbilEffectTarget) || (AbilityClass(lv_abilLink) == c_classIdCAbilMorph))) {

            lv_cooldownLink = CatalogFieldValueGet(c_gameCatalogAbil, lv_abilLink, "Cost[" + IntToString(0) + "].Cooldown.Link", lv_ownerofUnit);

            libNtve_gf_UnitRemoveCooldown(lp_unit, lv_cooldownLink);

            libNtve_gf_PlayerRemoveCooldown(lv_ownerofUnit, lv_cooldownLink);

            lv_chargeLink = CatalogFieldValueGet(c_gameCatalogAbil, lv_abilLink, "Cost[" + IntToString(0) + "].Charge.Link", lv_ownerofUnit);

            UnitAddChargeUsed(lp_unit, lv_chargeLink, -1.0);

            PlayerAddChargeUsed(lv_ownerofUnit, lv_cooldownLink, -1.0);

        }



    }

}



void libSprt_gf_DEBUGToggleUpdateDeathUIElements () {

    // Automatic Variable Declarations

    // Implementation

    if ((libGame_gv_heroDeath_RunDeathUIUpdates == true)) {

        libGame_gv_heroDeath_RunDeathUIUpdates = false;

    }

    else {

        libGame_gv_heroDeath_RunDeathUIUpdates = true;

    }

}



void libSprt_gf_DEBUGIncrementAllQuests (int lp_player, int lp_count) {

    // Variable Declarations

    int lv_tokenInfiniteThreshold;

    int lv_tokenHardCap;

    unit lv_itSelectedUnit;

    unitgroup lv_selectedUnits;

    int lv_itBehavior;

    string lv_tokenBehavior;

    int lv_currentTokenCount;

    int lv_newTokenCount;

    int lv_itConditionalIndex;

    int lv_tokenSoftCap;

    int lv_potentialTokenSoftCap;

    int lv_tokensToAdd;

    string lv_chargeLink;



    // Automatic Variable Declarations

    unitgroup auto3DF71D7D_g;

    int auto3DF71D7D_u;

    int auto4FF55E2E_ae;

    const int auto4FF55E2E_ai = 1;

    int autoCF0483F6_ae;

    const int autoCF0483F6_ai = 1;



    // Variable Initialization

    lv_tokenInfiniteThreshold = 65000;

    lv_selectedUnits = UnitGroupSelected(lp_player);

    lv_itConditionalIndex = 1;

    lv_chargeLink = "";



    // Implementation

    auto3DF71D7D_g = lv_selectedUnits;

    auto3DF71D7D_u = UnitGroupCount(auto3DF71D7D_g, c_unitCountAll);

    for (;; auto3DF71D7D_u -= 1) {

        lv_itSelectedUnit = UnitGroupUnitFromEnd(auto3DF71D7D_g, auto3DF71D7D_u);

        if (lv_itSelectedUnit == null) { break; }

        auto4FF55E2E_ae = UnitBehaviorCountAll(lv_itSelectedUnit);

        lv_itBehavior = 1;

        for ( ; ( (auto4FF55E2E_ai >= 0 && lv_itBehavior <= auto4FF55E2E_ae) || (auto4FF55E2E_ai < 0 && lv_itBehavior >= auto4FF55E2E_ae) ) ; lv_itBehavior += auto4FF55E2E_ai ) {

            lv_tokenBehavior = UnitBehaviorGet(lv_itSelectedUnit, lv_itBehavior);

            if ((CatalogFieldValueGet(c_gameCatalogBehavior, lv_tokenBehavior, "BehaviorCategories[" + IntToString(c_behaviorCategoryQuest) + "]", lp_player) == "1") && (lv_tokenBehavior != "AlarakSadismToken")) {

                lv_tokensToAdd = lp_count;

                lv_currentTokenCount = FixedToInt(UnitGetTokenCount(lv_itSelectedUnit, CatalogFieldValueGet(c_gameCatalogBehavior, lv_tokenBehavior, "TokenId", c_playerAny)));

                lv_tokenHardCap = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, lv_tokenBehavior, "Max", lp_player);

                if ((lv_currentTokenCount >= lv_tokenHardCap)) {

                    TextExpressionSetToken("Param/Expression/lib_Sprt_F4F0601C", "A", StringToText((lv_tokenBehavior)));

                    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_F4F0601C"), true);

                    continue;

                }



                lv_tokenSoftCap = 0;

                if ((lv_tokenHardCap >= lv_tokenInfiniteThreshold)) {

                    autoCF0483F6_ae = (CatalogFieldValueCount(c_gameCatalogBehavior, lv_tokenBehavior, "ConditionalEvents", c_playerAny) - 1);

                    lv_itConditionalIndex = 0;

                    for ( ; ( (autoCF0483F6_ai >= 0 && lv_itConditionalIndex <= autoCF0483F6_ae) || (autoCF0483F6_ai < 0 && lv_itConditionalIndex >= autoCF0483F6_ae) ) ; lv_itConditionalIndex += autoCF0483F6_ai ) {

                        lv_potentialTokenSoftCap = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, lv_tokenBehavior, "ConditionalEvents[" + IntToString(lv_itConditionalIndex) + "].CompareValue", c_playerAny);

                        if ((lv_potentialTokenSoftCap != 0)) {

                            lv_tokenSoftCap = MaxI(lv_tokenSoftCap, lv_potentialTokenSoftCap);

                        }

                        else {

                            break;

                        }

                    }

                }



                if ((lv_tokenHardCap >= lv_tokenInfiniteThreshold) && ((lv_tokenSoftCap == 0) || (lv_currentTokenCount >= lv_tokenSoftCap)) && (lv_tokensToAdd == 0)) {

                    lv_tokensToAdd = 5;

                }



                if ((lv_tokensToAdd == 0)) {

                    if ((lv_tokenHardCap >= lv_tokenInfiniteThreshold)) {

                        lv_newTokenCount = lv_tokenSoftCap;

                    }

                    else {

                        lv_newTokenCount = lv_tokenHardCap;

                    }

                    TextExpressionSetToken("Param/Expression/lib_Sprt_71F023F7", "A", StringToText((lv_tokenBehavior)));

                    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_71F023F7"), true);

                }

                else {

                    lv_newTokenCount = MinI((lv_tokensToAdd + lv_currentTokenCount), lv_tokenHardCap);

                    TextExpressionSetToken("Param/Expression/lib_Sprt_3D323D11", "B", IntToText(lv_tokensToAdd));

                    TextExpressionSetToken("Param/Expression/lib_Sprt_3D323D11", "A", StringToText((lv_tokenBehavior)));

                    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_3D323D11"), true);

                }

                UnitSetTokenCount(lv_itSelectedUnit, CatalogFieldValueGet(c_gameCatalogBehavior, lv_tokenBehavior, "TokenId", c_playerAny), lv_newTokenCount, lv_itSelectedUnit);

                if ((lv_tokenBehavior == "ButcherFreshMeatTokenCounter")) {

                    lv_chargeLink = CatalogFieldValueGet(c_gameCatalogAbil, "ButcherFreshMeatDummy", "Cost[" + IntToString(0) + "].Charge.Link", lp_player);

                    UnitAddChargeUsed(lv_itSelectedUnit, lv_chargeLink, (-(lv_newTokenCount - lv_currentTokenCount)));

                }



            }



        }

    }

}



fixed libSprt_gf_DebugGameTimeDelta () {

    // Automatic Variable Declarations

    // Implementation

    return libSprt_gv_debug_GameTimeDelta;

}



void libSprt_gf_DEBUGTalentsRespec (int lp_player, int lp_tier) {

    // Variable Declarations

    int lv_itButton;

    int lv_itBehavior;

    unit lv_itHeroUnit;

    unit lv_heroUnit;

    int lv_heroIndex;



    // Automatic Variable Declarations

    int auto77BD8986_ae;

    const int auto77BD8986_ai = 1;

    int autoD88DF097_ae;

    const int autoD88DF097_ai = 1;

    unitgroup auto2AC838C9_g;

    int auto2AC838C9_u;



    // Variable Initialization



    // Implementation

    lv_heroUnit = libGame_gv_players[lp_player].lv_heroUnit;

    lv_heroIndex = libGame_gv_players[lp_player].lv_heroIndex;

    auto77BD8986_ae = libGame_gv_talents_TalentChoices[lp_player][lp_tier].lv_numberOfTalentsForThisTier;

    lv_itButton = 1;

    for ( ; ( (auto77BD8986_ai >= 0 && lv_itButton <= auto77BD8986_ae) || (auto77BD8986_ai < 0 && lv_itButton >= auto77BD8986_ae) ) ; lv_itButton += auto77BD8986_ai ) {

        libGame_gf_RemoveTalentAbilityModificationsForPlayerAtTalent(lp_player, lp_tier, lv_itButton);

        PlayerRemoveTalent(lp_player, libGame_gv_talents_TalentChoices[lp_player][lp_tier].lv_talentData[lv_itButton].lv_talentCatalogLink);

        autoD88DF097_ae = libGame_gv_talents_TalentChoices[lp_player][lp_tier].lv_talentData[lv_itButton].lv_behaviorCount;

        lv_itBehavior = 1;

        for ( ; ( (autoD88DF097_ai >= 0 && lv_itBehavior <= autoD88DF097_ae) || (autoD88DF097_ai < 0 && lv_itBehavior >= autoD88DF097_ae) ) ; lv_itBehavior += autoD88DF097_ai ) {

            auto2AC838C9_g = libGame_gv_players[lp_player].lv_heroUnitGroup;

            auto2AC838C9_u = UnitGroupCount(auto2AC838C9_g, c_unitCountAll);

            for (;; auto2AC838C9_u -= 1) {

                lv_itHeroUnit = UnitGroupUnitFromEnd(auto2AC838C9_g, auto2AC838C9_u);

                if (lv_itHeroUnit == null) { break; }

                UnitBehaviorRemove(lv_itHeroUnit, libGame_gv_talents_TalentChoices[lp_player][lp_tier].lv_talentData[lv_itButton].lv_behaviors[lv_itBehavior], 1);

            }

        }

    }

    TalentTreeClearTier(lp_player, lp_tier);

    libGame_gv_talents_TalentChoices[lp_player][lp_tier].lv_selection = 0;

    libGame_gf_TalentsUpdateChoicePanelForPlayer(lp_player);

}



void libSprt_gf_DEBUGAddDynamicStacksofBehaviortoUnit (fixed lp_rate, string lp_behavior, int lp_player, unit lp_unit) {

    // Variable Declarations

    int lv_count;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    UnitBehaviorRemove(lp_unit, lp_behavior, 1000);

    lv_count = FloorI((libGame_gv_scalingTicks * lp_rate));

    UnitBehaviorAdd(lp_unit, lp_behavior, lp_unit, lv_count);

    TextExpressionSetToken("Param/Expression/lib_Sprt_76BB2D86", "A", IntToText(lv_count));

    TextExpressionSetToken("Param/Expression/lib_Sprt_76BB2D86", "A", IntToText(lv_count));

    TextExpressionSetToken("Param/Expression/lib_Sprt_76BB2D86", "B", StringToText(CatalogFieldValueGet(c_gameCatalogBehavior, lp_behavior, "Name", c_playerAny)));

    TextExpressionSetToken("Param/Expression/lib_Sprt_76BB2D86", "C", IntToText(lp_player));

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_76BB2D86"));

}



// Triggers

//--------------------------------------------------------------------------------------------------

// Trigger: #Include Support

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_IncludeSupport_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_IncludeSupport_Init () {

    libSprt_gt_IncludeSupport = TriggerCreate("libSprt_gt_IncludeSupport_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: AI Spawning Test

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_AISpawningTest_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(5, TextExpressionAssemble("Param/Expression/lib_Sprt_A8958054"), true);

    libGame_gv_players[1].lv_heroIndex = 1;

    libCore_gf_DataLoadHeroDataIntoIndex(libCore_gf_GetHeroFromIndex(libGame_gv_players[1].lv_heroIndex), 1);

    Wait(10.0, c_timeGame);

    ConsoleCommand("restart", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_AISpawningTest_Init () {

    libSprt_gt_AISpawningTest = TriggerCreate("libSprt_gt_AISpawningTest_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Automated Build Test

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_AutomatedBuildTest_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    playergroup autoE076AD7D_g;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(5, TextExpressionAssemble("Param/Expression/lib_Sprt_8F8ADE66"), true);

    libGame_gv_players[1].lv_heroIndex = 1;

    libCore_gf_DataLoadHeroDataIntoIndex(libCore_gf_GetHeroFromIndex(libGame_gv_players[1].lv_heroIndex), 1);

    Wait(2.0, c_timeGame);

    ConsoleCommand("speed 8", true, true);

    libSprt_gf_DEBUGStartGame();

    Wait(2.0, c_timeGame);

    CameraPan(1, UnitGroupCenterOfGroup(UnitGroupSelected(1)), 0.0, -1, 0.0, false);

    CameraFollowUnitGroup(1, UnitGroupSelected(1), true, false);

    CameraLockInput(1, true);

    Wait(8.0, c_timeGame);

    libAIAI_gf_HeroAITakeOverHeroForPlayer(1);

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 1));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 2));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 2));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 3));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 3));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 4));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 4));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 5));

    libAIAI_gf_HeroAIEnableAIForPlayer(PlayerGroupPlayer(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 5));

    Wait(240.0, c_timeGame);

    TriggerDebugOutput(5, TextExpressionAssemble("Param/Expression/lib_Sprt_DCA8C979"), true);

    autoE076AD7D_g = libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup;

    lv_player = -1;

    while (true) {

        	lv_player = PlayerGroupNextPlayer(autoE076AD7D_g, lv_player);

        	if (lv_player<0) { break; }

        	if ((lv_player <= libCore_gv_bALMaxPlayers)) {

            libAIAI_gf_HeroAIDisableAIForPlayer(lv_player);

            UnitKill(libGame_gv_players[lv_player].lv_heroUnit);

        }



    }

    Wait(90.0, c_timeGame);

    ConsoleCommand("exit", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_AutomatedBuildTest_Init () {

    libSprt_gt_AutomatedBuildTest = TriggerCreate("libSprt_gt_AutomatedBuildTest_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Spawn Heroes For Heroes Performance Test Map

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 1);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, 1);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 2);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, 2);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 3);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, 3);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 4);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, 4);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 5);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, 5);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 6);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, 6);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 7);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, 7);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 8);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, 8);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 9);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, 9);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 10);

    PlayerGroupAdd(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, 10);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Stitches"), 1, 1, 0.0, 1, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Arthas"), 1, 1, 0.0, 2, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Diablo"), 1, 1, 0.0, 3, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Tyrael"), 1, 1, 0.0, 4, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Nova"), 1, 1, 0.0, 5, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Barbarian"), 1, 1, 0.0, 6, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Kerrigan"), 1, 1, 0.0, 7, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("Uther"), 1, 1, 0.0, 8, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("WitchDoctor"), 1, 1, 0.0, 9, 0);

    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(libCore_gf_GetIndexFromHero("L90ETC"), 1, 1, 0.0, 10, 0);

    UnitBehaviorAdd(libGame_gv_players[6].lv_heroUnit, "Ultimate1Unlocked", libGame_gv_players[6].lv_heroUnit, 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap_Init () {

    libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap = TriggerCreate("libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Run Performance Test

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestRunPerformanceTest_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_targetPlayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libSprt_gv_performanceTestPerformanceTestRunning == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Sprt_DC9BF57F", "A", IntToText(GameTestConfigType()));

    TriggerDebugOutput(5, TextExpressionAssemble("Param/Expression/lib_Sprt_DC9BF57F"), true);

    TriggerEnable(libSprt_gt_PerformanceTestGetFPS, true);

    TriggerEnable(libSprt_gt_PerformanceTestOutputFPSToFile, true);

    TriggerEnable(libSprt_gt_PerformanceTestMaintainHeroHealth, true);

    libSprt_gf_PerformanceTestHeroSelectScreen();

    libSprt_gf_PerformanceTestHeroesIdleBeforeGame();

    libSprt_gf_PerformanceTestHeroesIdleGameStart();

    Wait(15.0, c_timeGame);

    libSprt_gf_PerformanceTestHeroesIdleMinionsFighting();

    libSprt_gf_PerformanceTestTwoHeroesActiveStart();

    Wait(20.0, c_timeGame);

    libSprt_gf_PerformanceTestTwoHeroesActiveInLane();

    libSprt_gf_PerformanceTestSixHeroesActiveStart();

    Wait(20.0, c_timeGame);

    libSprt_gf_PerformanceTestSixHeroesActiveInLane();

    libSprt_gf_PerformanceTestTenHeroesActiveStart();

    Wait(20.0, c_timeGame);

    libSprt_gf_PerformanceTestTenHeroesActiveInLane();

    libSprt_gf_PerformanceTestChaosTeamDisabled();

    Wait(30.0, c_timeGame);

    libSprt_gf_PerformanceTestOrderTeamPushingUnopposed();

    ConsoleCommand("exit", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestRunPerformanceTest_Init () {

    libSprt_gt_PerformanceTestRunPerformanceTest = TriggerCreate("libSprt_gt_PerformanceTestRunPerformanceTest_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Set Hero Choices

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestSetHeroChoices_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto69A5D4A6_ae = 10;

    const int auto69A5D4A6_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_players[1].lv_heroIndex = libCore_gf_GetIndexFromHero("Muradin");

    libGame_gv_players[2].lv_heroIndex = libCore_gf_GetIndexFromHero("Stitches");

    libGame_gv_players[3].lv_heroIndex = libCore_gf_GetIndexFromHero("Nova");

    libGame_gv_players[4].lv_heroIndex = libCore_gf_GetIndexFromHero("Uther");

    libGame_gv_players[5].lv_heroIndex = libCore_gf_GetIndexFromHero("Falstad");

    libGame_gv_players[6].lv_heroIndex = libCore_gf_GetIndexFromHero("Arthas");

    libGame_gv_players[7].lv_heroIndex = libCore_gf_GetIndexFromHero("Kerrigan");

    libGame_gv_players[8].lv_heroIndex = libCore_gf_GetIndexFromHero("DemonHunter");

    libGame_gv_players[9].lv_heroIndex = libCore_gf_GetIndexFromHero("Tassadar");

    libGame_gv_players[10].lv_heroIndex = libCore_gf_GetIndexFromHero("WitchDoctor");

    lv_itPlayer = 1;

    for ( ; ( (auto69A5D4A6_ai >= 0 && lv_itPlayer <= auto69A5D4A6_ae) || (auto69A5D4A6_ai < 0 && lv_itPlayer >= auto69A5D4A6_ae) ) ; lv_itPlayer += auto69A5D4A6_ai ) {

        if ((libGame_gv_players[lv_itPlayer].lv_heroIndex != 0)) {

            libCore_gf_DataLoadHeroDataIntoIndex(libCore_gf_GetHeroFromIndex(libGame_gv_players[lv_itPlayer].lv_heroIndex), lv_itPlayer);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestSetHeroChoices_Init () {

    libSprt_gt_PerformanceTestSetHeroChoices = TriggerCreate("libSprt_gt_PerformanceTestSetHeroChoices_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Get FPS

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestGetFPS_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    PerfTestGetFPS();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestGetFPS_Init () {

    libSprt_gt_PerformanceTestGetFPS = TriggerCreate("libSprt_gt_PerformanceTestGetFPS_Func");

    TriggerEnable(libSprt_gt_PerformanceTestGetFPS, false);

    TriggerAddEventTimePeriodic(libSprt_gt_PerformanceTestGetFPS, 0.0625, c_timeGame);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Output FPS To File

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestOutputFPSToFile_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(5, StringExternal("Param/Value/lib_Sprt_8CB44873"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestOutputFPSToFile_Init () {

    libSprt_gt_PerformanceTestOutputFPSToFile = TriggerCreate("libSprt_gt_PerformanceTestOutputFPSToFile_Func");

    TriggerEnable(libSprt_gt_PerformanceTestOutputFPSToFile, false);

    TriggerAddEventTimePeriodic(libSprt_gt_PerformanceTestOutputFPSToFile, 1.0, c_timeGame);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Performance Test - Maintain Hero Health

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_PerformanceTestMaintainHeroHealth_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_loop;



    // Automatic Variable Declarations

    int auto2B7B4FF6_ae;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    auto2B7B4FF6_ae = 10;

    lv_loop = 1;

    for ( ; lv_loop <= auto2B7B4FF6_ae ; lv_loop += 1 ) {

        UnitSetPropertyFixed(libGame_gv_players[lv_loop].lv_heroUnit, c_unitPropLifePercent, 100.0);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_PerformanceTestMaintainHeroHealth_Init () {

    libSprt_gt_PerformanceTestMaintainHeroHealth = TriggerCreate("libSprt_gt_PerformanceTestMaintainHeroHealth_Func");

    TriggerEnable(libSprt_gt_PerformanceTestMaintainHeroHealth, false);

    TriggerAddEventTimePeriodic(libSprt_gt_PerformanceTestMaintainHeroHealth, 0.5, c_timeGame);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stat Tracking - Start for Player

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStatTrackingStartforPlayer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_trackerPlayer;

    int lv_trackerPlayerHeroIndex;

    string lv_trackerPlayerHero;

    string lv_trackerPlayerStr;

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto2F434F2A_ae = libCore_gv_bALMaxPlayers;

    const int auto2F434F2A_ai = 1;



    // Variable Initialization

    lv_trackerPlayerStr = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) != "")) {

        lv_trackerPlayerStr = StringWord(EventChatMessage(false), 2);

        if ((StringToInt(lv_trackerPlayerStr) >= 1) && (StringToInt(lv_trackerPlayerStr) <= libCore_gv_bALMaxPlayers)) {

            libSprt_gf_StatTrackingStartTrackingforPlayer(StringToInt(lv_trackerPlayerStr));

        }

        else {

            lv_trackerPlayerHero = (lv_trackerPlayerStr);

            if ((libCore_gf_GetIndexFromHero(lv_trackerPlayerHero) > 0)) {

                lv_itPlayer = 1;

                for ( ; ( (auto2F434F2A_ai >= 0 && lv_itPlayer <= auto2F434F2A_ae) || (auto2F434F2A_ai < 0 && lv_itPlayer >= auto2F434F2A_ae) ) ; lv_itPlayer += auto2F434F2A_ai ) {

                    if ((libGame_gv_players[lv_itPlayer].lv_heroData.lv_heroCatalogLink == lv_trackerPlayerHero)) {

                        libSprt_gf_StatTrackingStartTrackingforPlayer(lv_itPlayer);

                    }



                }

            }



        }

    }

    else {

        libSprt_gf_StatTrackingStartTrackingforPlayer(EventPlayer());

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStatTrackingStartforPlayer_Init () {

    libSprt_gt_DEBUGStatTrackingStartforPlayer = TriggerCreate("libSprt_gt_DEBUGStatTrackingStartforPlayer_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStartforPlayer, c_playerAny, "StatTrackStart", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStartforPlayer, c_playerAny, "StatTrackerStart", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stat Tracking - Log Break

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStatTrackingLogBreak_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_trackerPlayer;

    int lv_trackerPlayerHeroIndex;

    string lv_trackerPlayerHero;

    string lv_trackerPlayerStr;

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto29B5A237_ae = libCore_gv_bALMaxPlayers;

    const int auto29B5A237_ai = 1;



    // Variable Initialization

    lv_trackerPlayerStr = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) != "")) {

        lv_trackerPlayerStr = StringWord(EventChatMessage(false), 2);

        if ((StringToInt(lv_trackerPlayerStr) >= 1) && (StringToInt(lv_trackerPlayerStr) <= libCore_gv_bALMaxPlayers)) {

            libSprt_gf_StatTrackingBreakTrackingforPlayer(StringToInt(lv_trackerPlayerStr));

        }

        else {

            lv_trackerPlayerHero = (lv_trackerPlayerStr);

            if ((libCore_gf_GetIndexFromHero(lv_trackerPlayerHero) > 0)) {

                lv_itPlayer = 1;

                for ( ; ( (auto29B5A237_ai >= 0 && lv_itPlayer <= auto29B5A237_ae) || (auto29B5A237_ai < 0 && lv_itPlayer >= auto29B5A237_ae) ) ; lv_itPlayer += auto29B5A237_ai ) {

                    if ((libGame_gv_players[lv_itPlayer].lv_heroData.lv_heroCatalogLink == lv_trackerPlayerHero)) {

                        libSprt_gf_StatTrackingBreakTrackingforPlayer(lv_itPlayer);

                    }



                }

            }



        }

    }

    else {

        libSprt_gf_StatTrackingBreakTrackingforPlayer(EventPlayer());

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStatTrackingLogBreak_Init () {

    libSprt_gt_DEBUGStatTrackingLogBreak = TriggerCreate("libSprt_gt_DEBUGStatTrackingLogBreak_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingLogBreak, c_playerAny, "StatTrackBreak", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingLogBreak, c_playerAny, "StatTrackerBreak", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stat Tracking - Stop

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStatTrackingStop_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_triggeringPlayer;

    int lv_entriesInDataTable;

    int lv_itEntry;

    int lv_itPlayer;

    string lv_effectName;

    int lv_trackerPlayerHeroIndex;

    string lv_trackerPlayerHero;

    string lv_trackerPlayerStr;



    // Automatic Variable Declarations

    const int auto6BCF4C98_ae = libCore_gv_bALMaxPlayers;

    const int auto6BCF4C98_ai = 1;



    // Variable Initialization

    lv_triggeringPlayer = EventPlayer();

    lv_effectName = "";

    lv_trackerPlayerStr = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) != "")) {

        lv_trackerPlayerStr = StringWord(EventChatMessage(false), 2);

        if ((StringToInt(lv_trackerPlayerStr) >= 1) && (StringToInt(lv_trackerPlayerStr) <= libCore_gv_bALMaxPlayers)) {

            libSprt_gf_StatTrackingStopTrackingforPlayer(StringToInt(lv_trackerPlayerStr));

        }

        else {

            lv_trackerPlayerHero = (lv_trackerPlayerStr);

            if ((libCore_gf_GetIndexFromHero(lv_trackerPlayerHero) > 0)) {

                lv_itPlayer = 1;

                for ( ; ( (auto6BCF4C98_ai >= 0 && lv_itPlayer <= auto6BCF4C98_ae) || (auto6BCF4C98_ai < 0 && lv_itPlayer >= auto6BCF4C98_ae) ) ; lv_itPlayer += auto6BCF4C98_ai ) {

                    if ((libGame_gv_players[lv_itPlayer].lv_heroData.lv_heroCatalogLink == lv_trackerPlayerHero)) {

                        libSprt_gf_StatTrackingStopTrackingforPlayer(lv_itPlayer);

                    }



                }

            }



        }

    }

    else {

        libSprt_gf_StatTrackingStopTrackingforPlayer(EventPlayer());

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStatTrackingStop_Init () {

    libSprt_gt_DEBUGStatTrackingStop = TriggerCreate("libSprt_gt_DEBUGStatTrackingStop_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStop, c_playerAny, "StatTrackStop", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStop, c_playerAny, "StatTrackerStop", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stat Tracking - Start Tracking for All Players

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStatTrackingStartTrackingforAllPlayers_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto2BCE18E9_g;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto2BCE18E9_g = PlayerGroupActive();

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(auto2BCE18E9_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	libSprt_gf_StatTrackingStartTrackingforPlayer(lv_itPlayer);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStatTrackingStartTrackingforAllPlayers_Init () {

    libSprt_gt_DEBUGStatTrackingStartTrackingforAllPlayers = TriggerCreate("libSprt_gt_DEBUGStatTrackingStartTrackingforAllPlayers_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stat Tracking - Stop Tracking for All Players

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto87C42493_g;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto87C42493_g = PlayerGroupActive();

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(auto87C42493_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	libSprt_gf_StatTrackingStopTrackingforPlayer(lv_itPlayer);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers_Init () {

    libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers = TriggerCreate("libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers, c_playerAny, "StatTrackStopAll", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers, c_playerAny, "StatTrackerStopAll", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers, c_playerAny, "stattrackstopall", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers, c_playerAny, "stattrackerstopall", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Stat Tracking - Damage Tracking

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_StatTrackingDamageTracking_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_damagingPlayer;

    fixed lv_damageAttempted;

    fixed lv_damageDone;

    int lv_itDamageEffect;

    string lv_damagingEffect;

    string lv_damagingEffectName;

    string lv_damagingEffectCountAsStr;

    string lv_damagingEffectPlayerAsStr;

    bool lv_effectFound;

    string lv_lookupNamePrefix;



    // Automatic Variable Declarations

    int auto8BE242BD_ae;

    const int auto8BE242BD_ai = 1;



    // Variable Initialization

    lv_damagingPlayer = EventUnitDamageSourcePlayer();

    lv_damagingEffectName = "";

    lv_damagingEffectCountAsStr = "";

    lv_damagingEffectPlayerAsStr = "";

    lv_lookupNamePrefix = "";



    // Conditions

    if (testConds) {

        if (!((lv_damagingPlayer > 0))) {

            return false;

        }



        if (!((lv_damagingPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }



        if (!((libSprt_gv_statTrackingOn[lv_damagingPlayer] == true))) {

            return false;

        }



        if (!((lv_damagingPlayer != EventPlayer()))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_damageAttempted = EventUnitDamageAttempted();

    lv_damageDone = EventUnitDamageAmount();

    lv_damagingEffect = EventUnitDamageEffect();

    lv_damagingEffectName = (lv_damagingEffect);

    lv_damagingEffectPlayerAsStr = IntToString(lv_damagingPlayer);

    auto8BE242BD_ae = DataTableGetInt(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":EffectInstanceCount"));

    lv_itDamageEffect = 1;

    for ( ; ( (auto8BE242BD_ai >= 0 && lv_itDamageEffect <= auto8BE242BD_ae) || (auto8BE242BD_ai < 0 && lv_itDamageEffect >= auto8BE242BD_ae) ) ; lv_itDamageEffect += auto8BE242BD_ai ) {

        if ((DataTableGetString(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":Effect" + IntToString(lv_itDamageEffect))) == lv_damagingEffectName)) {

            lv_effectFound = true;

            break;

        }



    }

    if ((lv_effectFound != true)) {

        DataTableSetInt(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":EffectInstanceCount"), (DataTableGetInt(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":EffectInstanceCount")) + 1));

        DataTableSetString(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":Effect" + IntToString(DataTableGetInt(true, ("DMGStatTrackPlayer" + lv_damagingEffectPlayerAsStr + ":EffectInstanceCount")))), lv_damagingEffectName);

    }



    if ((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true)) {

        lv_lookupNamePrefix = ("DMG" + lv_damagingEffectName + "Heroic");

    }

    else {

        lv_lookupNamePrefix = ("DMG" + lv_damagingEffectName);

    }

    lv_damagingEffectCountAsStr = IntToString(DataTableGetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_damagingEffectPlayerAsStr)));

    DataTableSetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_damagingEffectPlayerAsStr), (DataTableGetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_damagingEffectPlayerAsStr)) + 1));

    DataTableSetFixed(true, (lv_lookupNamePrefix + ":DamageAttempted" + lv_damagingEffectPlayerAsStr), (DataTableGetFixed(true, (lv_lookupNamePrefix + ":DamageAttempted" + lv_damagingEffectPlayerAsStr)) + lv_damageAttempted));

    DataTableSetFixed(true, (lv_lookupNamePrefix + ":DamageDone" + lv_damagingEffectPlayerAsStr), (DataTableGetFixed(true, (lv_lookupNamePrefix + ":DamageDone" + lv_damagingEffectPlayerAsStr)) + lv_damageDone));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_StatTrackingDamageTracking_Init () {

    libSprt_gt_StatTrackingDamageTracking = TriggerCreate("libSprt_gt_StatTrackingDamageTracking_Func");

    TriggerEnable(libSprt_gt_StatTrackingDamageTracking, false);

    TriggerAddEventUnitDamaged(libSprt_gt_StatTrackingDamageTracking, null, c_unitDamageTypeAny, c_unitDamageEither, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Stat Tracking - Healing Tracking

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_StatTrackingHealingTracking_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_healingPlayer;

    fixed lv_healingAttempted;

    fixed lv_healingDone;

    int lv_itHealingEffect;

    string lv_healingEffect;

    string lv_healingEffectName;

    string lv_healingEffectCountAsStr;

    string lv_healingEffectPlayerAsStr;

    bool lv_effectFound;

    string lv_lookupNamePrefix;



    // Automatic Variable Declarations

    int auto03E8CDA8_ae;

    const int auto03E8CDA8_ai = 1;



    // Variable Initialization

    lv_healingPlayer = UnitGetOwner(EventUnitHealLaunchUnit());

    lv_healingEffectName = "";

    lv_healingEffectCountAsStr = "";

    lv_healingEffectPlayerAsStr = "";

    lv_lookupNamePrefix = "";



    // Conditions

    if (testConds) {

        if (!((lv_healingPlayer > 0))) {

            return false;

        }



        if (!((lv_healingPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }



        if (!((libSprt_gv_statTrackingOn[lv_healingPlayer] == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_healingDone = EventUnitHealAmount();

    lv_healingEffect = EventUnitHealEffect();

    lv_healingEffectName = (lv_healingEffect);

    lv_healingEffectPlayerAsStr = IntToString(lv_healingPlayer);

    auto03E8CDA8_ae = DataTableGetInt(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":EffectInstanceCount"));

    lv_itHealingEffect = 1;

    for ( ; ( (auto03E8CDA8_ai >= 0 && lv_itHealingEffect <= auto03E8CDA8_ae) || (auto03E8CDA8_ai < 0 && lv_itHealingEffect >= auto03E8CDA8_ae) ) ; lv_itHealingEffect += auto03E8CDA8_ai ) {

        if ((DataTableGetString(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":Effect" + IntToString(lv_itHealingEffect))) == lv_healingEffectName)) {

            lv_effectFound = true;

            break;

        }



    }

    if ((lv_effectFound != true)) {

        DataTableSetInt(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":EffectInstanceCount"), (DataTableGetInt(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":EffectInstanceCount")) + 1));

        DataTableSetString(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":Effect" + IntToString(DataTableGetInt(true, ("HLGStatTrackPlayer" + lv_healingEffectPlayerAsStr + ":EffectInstanceCount")))), lv_healingEffectName);

    }



    if ((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true)) {

        lv_lookupNamePrefix = ("HLG" + lv_healingEffectName + "Heroic");

    }

    else {

        lv_lookupNamePrefix = ("HLG" + lv_healingEffectName);

    }

    lv_healingEffectCountAsStr = IntToString(DataTableGetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_healingEffectPlayerAsStr)));

    DataTableSetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_healingEffectPlayerAsStr), (DataTableGetInt(true, (lv_lookupNamePrefix + ":EffectCount" + lv_healingEffectPlayerAsStr)) + 1));

    DataTableSetFixed(true, (lv_lookupNamePrefix + ":HealingDone" + lv_healingEffectPlayerAsStr), (DataTableGetFixed(true, (lv_lookupNamePrefix + ":HealingDone" + lv_healingEffectPlayerAsStr)) + lv_healingDone));

    libGame_gv_scoreValues[lv_healingPlayer].lv_healing += FixedToInt(lv_healingDone);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_StatTrackingHealingTracking_Init () {

    libSprt_gt_StatTrackingHealingTracking = TriggerCreate("libSprt_gt_StatTrackingHealingTracking_Func");

    TriggerEnable(libSprt_gt_StatTrackingHealingTracking, false);

    TriggerAddEventUnitHealed(libSprt_gt_StatTrackingHealingTracking, null, c_unitVitalAny, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Stat Tracking - Game Over

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_StatTrackingGameOver_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto42E03538_ae = libCore_gv_bALMaxPlayers;

    const int auto42E03538_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itPlayer = 1;

    for ( ; ( (auto42E03538_ai >= 0 && lv_itPlayer <= auto42E03538_ae) || (auto42E03538_ai < 0 && lv_itPlayer >= auto42E03538_ae) ) ; lv_itPlayer += auto42E03538_ai ) {

        if ((libSprt_gv_statTrackingOn[lv_itPlayer] == true)) {

            libSprt_gf_StatTrackingReportStats(lv_itPlayer);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_StatTrackingGameOver_Init () {

    libSprt_gt_StatTrackingGameOver = TriggerCreate("libSprt_gt_StatTrackingGameOver_Func");

    libGame_gf_GameOverEvent(libSprt_gt_StatTrackingGameOver);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data Mining - Listen For Regen Globes

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DataMiningListenForRegenGlobes_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_triggeringPlayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_triggeringPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerTarget);

    if (((lv_triggeringPlayer <= 0) || (lv_triggeringPlayer > libCore_gv_bALMaxPlayers))) {

        return true;

    }



    libGame_gv_players[lv_triggeringPlayer].lv_regenGlobes += 1;

    StatEventCreate("RegenGlobePickedUp");

    StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lv_triggeringPlayer);

    StatEventSend(StatEventLastCreated());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DataMiningListenForRegenGlobes_Init () {

    libSprt_gt_DataMiningListenForRegenGlobes = TriggerCreate("libSprt_gt_DataMiningListenForRegenGlobes_Func");

    TriggerEnable(libSprt_gt_DataMiningListenForRegenGlobes, false);

    TriggerAddEventPlayerEffectUsed(libSprt_gt_DataMiningListenForRegenGlobes, c_playerAny, "RegenGlobeImpactSet");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data Mining - Periodic Data Send Periodic Event Trigger

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DataMiningPeriodicDataSend();

    TimerStart(libSprt_gv_dataMiningPeriodicTimer, libSprt_gv_dataMiningPeriodicSendPeriod, false, c_timeGame);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger_Init () {

    libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger = TriggerCreate("libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger_Func");

    TriggerEnable(libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger, false);

    TriggerAddEventTimer(libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger, libSprt_gv_dataMiningPeriodicTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Force Hero Mastery Ring 0

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGForceHeroMasteryRing0_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_player;



    // Automatic Variable Declarations

    unitgroup autoDB9E388B_g;

    int autoDB9E388B_u;

    unit autoDB9E388B_var;

    int autoC5F27F1E_ae;

    unitgroup autoF68CEDB8_g;

    int autoF68CEDB8_u;

    unit autoF68CEDB8_var;



    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((EventChatMessage(false) == "-mre0")) {

        lv_player = 6;

    }



    if ((EventChatMessage(false) == "-mra0")) {

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_C5AE1FBC"), true);

        autoC5F27F1E_ae = libCore_gv_bALMaxPlayers;

        lv_i = 1;

        for ( ; lv_i <= autoC5F27F1E_ae ; lv_i += 1 ) {

            libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "HeroRingMasteryUpgrade", 0);

            autoF68CEDB8_g = libGame_gv_players[lv_i].lv_heroUnitGroup;

            autoF68CEDB8_u = UnitGroupCount(autoF68CEDB8_g, c_unitCountAll);

            for (;; autoF68CEDB8_u -= 1) {

                autoF68CEDB8_var = UnitGroupUnitFromEnd(autoF68CEDB8_g, autoF68CEDB8_u);

                if (autoF68CEDB8_var == null) { break; }

                libNtve_gf_SendActorMessageToUnit(autoF68CEDB8_var, "Signal MasteryRingCreation");

            }

        }

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_6EEBE7A1", "A", IntToText(lv_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_6EEBE7A1"), true);

        libNtve_gf_SetUpgradeLevelForPlayer(lv_player, "HeroRingMasteryUpgrade", 0);

        autoDB9E388B_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        autoDB9E388B_u = UnitGroupCount(autoDB9E388B_g, c_unitCountAll);

        for (;; autoDB9E388B_u -= 1) {

            autoDB9E388B_var = UnitGroupUnitFromEnd(autoDB9E388B_g, autoDB9E388B_u);

            if (autoDB9E388B_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(autoDB9E388B_var, "Signal MasteryRingCreation");

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGForceHeroMasteryRing0_Init () {

    libSprt_gt_DEBUGForceHeroMasteryRing0 = TriggerCreate("libSprt_gt_DEBUGForceHeroMasteryRing0_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing0, c_playerAny, "-mr0", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing0, c_playerAny, "-mre0", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing0, c_playerAny, "-mra0", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Force Hero Mastery Ring 1

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGForceHeroMasteryRing1_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_player;



    // Automatic Variable Declarations

    unitgroup auto7EEB58A8_g;

    int auto7EEB58A8_u;

    unit auto7EEB58A8_var;

    int auto18438449_ae;

    unitgroup auto3FCC575C_g;

    int auto3FCC575C_u;

    unit auto3FCC575C_var;



    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((EventChatMessage(false) == "-mre1")) {

        lv_player = 6;

    }



    if ((EventChatMessage(false) == "-mra1")) {

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_43C803F8"), true);

        auto18438449_ae = libCore_gv_bALMaxPlayers;

        lv_i = 1;

        for ( ; lv_i <= auto18438449_ae ; lv_i += 1 ) {

            libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "HeroRingMasteryUpgrade", 1);

            auto3FCC575C_g = libGame_gv_players[lv_i].lv_heroUnitGroup;

            auto3FCC575C_u = UnitGroupCount(auto3FCC575C_g, c_unitCountAll);

            for (;; auto3FCC575C_u -= 1) {

                auto3FCC575C_var = UnitGroupUnitFromEnd(auto3FCC575C_g, auto3FCC575C_u);

                if (auto3FCC575C_var == null) { break; }

                libNtve_gf_SendActorMessageToUnit(auto3FCC575C_var, "Signal MasteryRingCreation");

            }

        }

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_AAD84D88", "A", IntToText(lv_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_AAD84D88"), true);

        libNtve_gf_SetUpgradeLevelForPlayer(lv_player, "HeroRingMasteryUpgrade", 1);

        auto7EEB58A8_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        auto7EEB58A8_u = UnitGroupCount(auto7EEB58A8_g, c_unitCountAll);

        for (;; auto7EEB58A8_u -= 1) {

            auto7EEB58A8_var = UnitGroupUnitFromEnd(auto7EEB58A8_g, auto7EEB58A8_u);

            if (auto7EEB58A8_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(auto7EEB58A8_var, "Signal MasteryRingCreation");

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGForceHeroMasteryRing1_Init () {

    libSprt_gt_DEBUGForceHeroMasteryRing1 = TriggerCreate("libSprt_gt_DEBUGForceHeroMasteryRing1_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing1, c_playerAny, "-mr1", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing1, c_playerAny, "-mre1", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing1, c_playerAny, "-mra1", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Force Hero Mastery Ring 2

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGForceHeroMasteryRing2_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_player;



    // Automatic Variable Declarations

    unitgroup autoCE596295_g;

    int autoCE596295_u;

    unit autoCE596295_var;

    int autoF7B63C6E_ae;

    unitgroup auto1E2BEC69_g;

    int auto1E2BEC69_u;

    unit auto1E2BEC69_var;



    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((EventChatMessage(false) == "-mre2")) {

        lv_player = 6;

    }



    if ((EventChatMessage(false) == "-mra2")) {

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_8395C080"), true);

        autoF7B63C6E_ae = libCore_gv_bALMaxPlayers;

        lv_i = 1;

        for ( ; lv_i <= autoF7B63C6E_ae ; lv_i += 1 ) {

            libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "HeroRingMasteryUpgrade", 2);

            auto1E2BEC69_g = libGame_gv_players[lv_i].lv_heroUnitGroup;

            auto1E2BEC69_u = UnitGroupCount(auto1E2BEC69_g, c_unitCountAll);

            for (;; auto1E2BEC69_u -= 1) {

                auto1E2BEC69_var = UnitGroupUnitFromEnd(auto1E2BEC69_g, auto1E2BEC69_u);

                if (auto1E2BEC69_var == null) { break; }

                libNtve_gf_SendActorMessageToUnit(auto1E2BEC69_var, "Signal MasteryRingCreation");

            }

        }

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_B1FD42AF", "A", IntToText(lv_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_B1FD42AF"), true);

        libNtve_gf_SetUpgradeLevelForPlayer(lv_player, "HeroRingMasteryUpgrade", 2);

        autoCE596295_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        autoCE596295_u = UnitGroupCount(autoCE596295_g, c_unitCountAll);

        for (;; autoCE596295_u -= 1) {

            autoCE596295_var = UnitGroupUnitFromEnd(autoCE596295_g, autoCE596295_u);

            if (autoCE596295_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(autoCE596295_var, "Signal MasteryRingCreation");

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGForceHeroMasteryRing2_Init () {

    libSprt_gt_DEBUGForceHeroMasteryRing2 = TriggerCreate("libSprt_gt_DEBUGForceHeroMasteryRing2_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing2, c_playerAny, "-mr2", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing2, c_playerAny, "-mre2", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing2, c_playerAny, "-mra2", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Force Hero Mastery Ring 3

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGForceHeroMasteryRing3_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_player;



    // Automatic Variable Declarations

    unitgroup auto57FC40ED_g;

    int auto57FC40ED_u;

    unit auto57FC40ED_var;

    int auto5CD613F0_ae;

    unitgroup auto688AC00F_g;

    int auto688AC00F_u;

    unit auto688AC00F_var;



    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((EventChatMessage(false) == "-mre3")) {

        lv_player = 6;

    }



    if ((EventChatMessage(false) == "-mra3")) {

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_9F8C0AB0"), true);

        auto5CD613F0_ae = libCore_gv_bALMaxPlayers;

        lv_i = 1;

        for ( ; lv_i <= auto5CD613F0_ae ; lv_i += 1 ) {

            libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "HeroRingMasteryUpgrade", 3);

            auto688AC00F_g = libGame_gv_players[lv_i].lv_heroUnitGroup;

            auto688AC00F_u = UnitGroupCount(auto688AC00F_g, c_unitCountAll);

            for (;; auto688AC00F_u -= 1) {

                auto688AC00F_var = UnitGroupUnitFromEnd(auto688AC00F_g, auto688AC00F_u);

                if (auto688AC00F_var == null) { break; }

                libNtve_gf_SendActorMessageToUnit(auto688AC00F_var, "Signal MasteryRingCreation");

            }

        }

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_AA0119B9", "A", IntToText(lv_player));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_AA0119B9"), true);

        libNtve_gf_SetUpgradeLevelForPlayer(lv_player, "HeroRingMasteryUpgrade", 3);

        auto57FC40ED_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        auto57FC40ED_u = UnitGroupCount(auto57FC40ED_g, c_unitCountAll);

        for (;; auto57FC40ED_u -= 1) {

            auto57FC40ED_var = UnitGroupUnitFromEnd(auto57FC40ED_g, auto57FC40ED_u);

            if (auto57FC40ED_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(auto57FC40ED_var, "Signal MasteryRingCreation");

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGForceHeroMasteryRing3_Init () {

    libSprt_gt_DEBUGForceHeroMasteryRing3 = TriggerCreate("libSprt_gt_DEBUGForceHeroMasteryRing3_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing3, c_playerAny, "-mr3", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing3, c_playerAny, "-mre3", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRing3, c_playerAny, "-mra3", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Force Hero Mastery Ring Rando

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGForceHeroMasteryRingRando_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    int lv_k;

    int lv_player;



    // Automatic Variable Declarations

    int autoB3844838_ae;

    unitgroup auto7F5A7DC7_g;

    int auto7F5A7DC7_u;

    unit auto7F5A7DC7_var;

    int autoF65E787E_ae;

    unitgroup autoE82B844E_g;

    int autoE82B844E_u;

    unit autoE82B844E_var;



    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Sprt_AF44B7C2", "A", IntToText(lv_player));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_AF44B7C2"), true);

    autoB3844838_ae = libCore_gv_bALMaxPlayers;

    lv_k = 1;

    for ( ; lv_k <= autoB3844838_ae ; lv_k += 1 ) {

        libNtve_gf_SetUpgradeLevelForPlayer(lv_k, "HeroRingMasteryUpgrade", 0);

        auto7F5A7DC7_g = libGame_gv_players[lv_k].lv_heroUnitGroup;

        auto7F5A7DC7_u = UnitGroupCount(auto7F5A7DC7_g, c_unitCountAll);

        for (;; auto7F5A7DC7_u -= 1) {

            auto7F5A7DC7_var = UnitGroupUnitFromEnd(auto7F5A7DC7_g, auto7F5A7DC7_u);

            if (auto7F5A7DC7_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(auto7F5A7DC7_var, "Signal MasteryRingCreation");

        }

    }

    Wait(0.0625, c_timeGame);

    autoF65E787E_ae = libCore_gv_bALMaxPlayers;

    lv_k = 1;

    for ( ; lv_k <= autoF65E787E_ae ; lv_k += 1 ) {

        libNtve_gf_SetUpgradeLevelForPlayer(lv_k, "HeroRingMasteryUpgrade", RandomInt(0, libSprt_gv_heroMasteryRingsMaxRank));

        autoE82B844E_g = libGame_gv_players[lv_k].lv_heroUnitGroup;

        autoE82B844E_u = UnitGroupCount(autoE82B844E_g, c_unitCountAll);

        for (;; autoE82B844E_u -= 1) {

            autoE82B844E_var = UnitGroupUnitFromEnd(autoE82B844E_g, autoE82B844E_u);

            if (autoE82B844E_var == null) { break; }

            libNtve_gf_SendActorMessageToUnit(autoE82B844E_var, "Signal MasteryRingCreation");

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGForceHeroMasteryRingRando_Init () {

    libSprt_gt_DEBUGForceHeroMasteryRingRando = TriggerCreate("libSprt_gt_DEBUGForceHeroMasteryRingRando_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGForceHeroMasteryRingRando, c_playerAny, "-mrrando", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Init

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsInit_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_QACheatsUIInit();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsInit_Init () {

    libSprt_gt_QACheatsInit = TriggerCreate("libSprt_gt_QACheatsInit_Func");

    TriggerAddEventMapInit(libSprt_gt_QACheatsInit);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Toggle Cheats Dialog

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_ToggleCheatsDialog_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((DialogIsVisible(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, EventPlayer()) == false)) {

        DialogSetVisible(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, libCore_gv_playerGroupFromPlayer[EventPlayer()], true);

        libSprt_gv_qACheatsSelectedUnit = UnitGroupUnit(UnitGroupFilterPlayer(libGame_gv_players[EventPlayer()].lv_heroUnitGroup, EventPlayer(), 0), 1);

    }

    else {

        DialogSetVisible(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, libCore_gv_playerGroupFromPlayer[EventPlayer()], false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_ToggleCheatsDialog_Init () {

    libSprt_gt_ToggleCheatsDialog = TriggerCreate("libSprt_gt_ToggleCheatsDialog_Func");

    TriggerAddEventChatMessage(libSprt_gt_ToggleCheatsDialog, c_playerAny, "-devcheats", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Close Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsCloseButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_triggeringplayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_closeButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    DialogSetVisible(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, PlayerGroupAll(), false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsCloseButtonClicked_Init () {

    libSprt_gt_QACheatsCloseButtonClicked = TriggerCreate("libSprt_gt_QACheatsCloseButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsCloseButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Allied Control Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsAlliedControlCheckboxClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_playerGroup;



    // Automatic Variable Declarations

    playergroup autoE40422D2_g;

    int autoE40422D2_var;



    // Variable Initialization

    lv_playerGroup = PlayerGroupEmpty();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_alliedControlCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, true), lv_playerGroup);

    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, true), lv_playerGroup);

    PlayerGroupAdd(lv_playerGroup, 15);

    PlayerGroupRemove(lv_playerGroup, EventPlayer());

    autoE40422D2_g = PlayerGroupAll();

    autoE40422D2_var = -1;

    while (true) {

        	autoE40422D2_var = PlayerGroupNextPlayer(autoE40422D2_g, autoE40422D2_var);

        	if (autoE40422D2_var<0) { break; }

        	if ((libNtve_gf_DialogItemIsChecked(libSprt_gv_qACheatsControlsPanel.lv_alliedControlCheckbox, EventPlayer()) == true)) {

            PlayerSetAlliance(autoE40422D2_var, c_allianceIdControl, EventPlayer(), true);

        }

        else {

            PlayerSetAlliance(autoE40422D2_var, c_allianceIdControl, EventPlayer(), false);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsAlliedControlCheckboxClicked_Init () {

    libSprt_gt_QACheatsAlliedControlCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsAlliedControlCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsAlliedControlCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - ShowMap Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsShowMapCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_showMapCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("sm", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsShowMapCheckboxClicked_Init () {

    libSprt_gt_QACheatsShowMapCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsShowMapCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsShowMapCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Vision Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsVisionCheckboxClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_playerGroup;



    // Automatic Variable Declarations

    playergroup autoFA5F1A65_g;

    int autoFA5F1A65_var;



    // Variable Initialization

    lv_playerGroup = PlayerGroupEmpty();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_visionCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_PlayersOnTeamHeroes(libGame_gf_EnemyTeamNumberOfPlayer(EventPlayer()), false), lv_playerGroup);

    autoFA5F1A65_g = lv_playerGroup;

    autoFA5F1A65_var = -1;

    while (true) {

        	autoFA5F1A65_var = PlayerGroupNextPlayer(autoFA5F1A65_g, autoFA5F1A65_var);

        	if (autoFA5F1A65_var<0) { break; }

        	if ((libNtve_gf_DialogItemIsChecked(libSprt_gv_qACheatsControlsPanel.lv_visionCheckbox, EventPlayer()) == true)) {

            PlayerSetAlliance(autoFA5F1A65_var, c_allianceIdVision, EventPlayer(), true);

        }

        else {

            PlayerSetAlliance(autoFA5F1A65_var, c_allianceIdVision, EventPlayer(), false);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsVisionCheckboxClicked_Init () {

    libSprt_gt_QACheatsVisionCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsVisionCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsVisionCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Cooldowns Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsCooldownsCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_cooldownsCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("cd", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsCooldownsCheckboxClicked_Init () {

    libSprt_gt_QACheatsCooldownsCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsCooldownsCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsCooldownsCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Grid Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsGridCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_gridCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("grid", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsGridCheckboxClicked_Init () {

    libSprt_gt_QACheatsGridCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsGridCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsGridCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Visualize Effects Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_tVECheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("tve", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked_Init () {

    libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Toggle Free Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsToggleFreeCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_freeCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("free", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsToggleFreeCheckboxClicked_Init () {

    libSprt_gt_QACheatsToggleFreeCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsToggleFreeCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsToggleFreeCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Toggle Selection Checkbox Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsToggleSelectionCheckboxClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_toggleSelectionCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DEBUGToggleSelection();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsToggleSelectionCheckboxClicked_Init () {

    libSprt_gt_QACheatsToggleSelectionCheckboxClicked = TriggerCreate("libSprt_gt_QACheatsToggleSelectionCheckboxClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsToggleSelectionCheckboxClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Toggle Disable Weapons Checkbox Checked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    playergroup auto9624427A_g;

    string auto15CCCBB9_val;

    unitgroup auto53CEF6E4_g;

    int auto53CEF6E4_u;

    unit auto53CEF6E4_var;

    unitgroup autoF8B0DACE_g;

    int autoF8B0DACE_u;

    unit autoF8B0DACE_var;

    playergroup auto44D932E4_g;

    string autoF4835C8F_val;

    unitgroup auto534BAF92_g;

    int auto534BAF92_u;

    unit auto534BAF92_var;

    unitgroup auto4D4E2213_g;

    int auto4D4E2213_u;

    unit auto4D4E2213_var;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_toggleWeaponsCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libNtve_gf_DialogItemIsChecked(libSprt_gv_qACheatsControlsPanel.lv_toggleWeaponsCheckbox, EventPlayer()) == true)) {

        libSprt_gv_qACheatsWeaponsDisabled = true;

        auto44D932E4_g = PlayerGroupAll();

        lv_player = -1;

        while (true) {

            	lv_player = PlayerGroupNextPlayer(auto44D932E4_g, lv_player);

            	if (lv_player<0) { break; }

            	autoF4835C8F_val = UnitGetType(libGame_gv_players[lv_player].lv_heroUnit);

            if (autoF4835C8F_val == "HeroLostVikingsController") {

                auto534BAF92_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

                auto534BAF92_u = UnitGroupCount(auto534BAF92_g, c_unitCountAll);

                for (;; auto534BAF92_u -= 1) {

                    auto534BAF92_var = UnitGroupUnitFromEnd(auto534BAF92_g, auto534BAF92_u);

                    if (auto534BAF92_var == null) { break; }

                    UnitBehaviorAddPlayer(auto534BAF92_var, "DisableWeaponsBehavior", 15, 1);

                }

            }

            else if (autoF4835C8F_val == "HeroChen") {

                auto4D4E2213_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

                auto4D4E2213_u = UnitGroupCount(auto4D4E2213_g, c_unitCountAll);

                for (;; auto4D4E2213_u -= 1) {

                    auto4D4E2213_var = UnitGroupUnitFromEnd(auto4D4E2213_g, auto4D4E2213_u);

                    if (auto4D4E2213_var == null) { break; }

                    UnitBehaviorAddPlayer(auto4D4E2213_var, "DisableWeaponsBehavior", 15, 1);

                }

            }

            else {

                UnitBehaviorAddPlayer(libGame_gv_players[lv_player].lv_heroUnit, "DisableWeaponsBehavior", 15, 1);

            }

        }

    }

    else {

        libSprt_gv_qACheatsWeaponsDisabled = false;

        auto9624427A_g = PlayerGroupAll();

        lv_player = -1;

        while (true) {

            	lv_player = PlayerGroupNextPlayer(auto9624427A_g, lv_player);

            	if (lv_player<0) { break; }

            	auto15CCCBB9_val = UnitGetType(libGame_gv_players[lv_player].lv_heroUnit);

            if (auto15CCCBB9_val == "HeroLostVikingsController") {

                auto53CEF6E4_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

                auto53CEF6E4_u = UnitGroupCount(auto53CEF6E4_g, c_unitCountAll);

                for (;; auto53CEF6E4_u -= 1) {

                    auto53CEF6E4_var = UnitGroupUnitFromEnd(auto53CEF6E4_g, auto53CEF6E4_u);

                    if (auto53CEF6E4_var == null) { break; }

                    UnitBehaviorRemovePlayer(auto53CEF6E4_var, "DisableWeaponsBehavior", 15, 1);

                }

            }

            else if (auto15CCCBB9_val == "HeroChen") {

                autoF8B0DACE_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

                autoF8B0DACE_u = UnitGroupCount(autoF8B0DACE_g, c_unitCountAll);

                for (;; autoF8B0DACE_u -= 1) {

                    autoF8B0DACE_var = UnitGroupUnitFromEnd(autoF8B0DACE_g, autoF8B0DACE_u);

                    if (autoF8B0DACE_var == null) { break; }

                    UnitBehaviorRemovePlayer(autoF8B0DACE_var, "DisableWeaponsBehavior", 15, 1);

                }

            }

            else {

                UnitBehaviorRemovePlayer(libGame_gv_players[lv_player].lv_heroUnit, "DisableWeaponsBehavior", 15, 1);

            }

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked_Init () {

    libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked = TriggerCreate("libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Disable Weapons On Spawn

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsDisableWeaponsOnSpawn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIdx;

    int lv_player;



    // Automatic Variable Declarations

    string auto9CF292A2_val;

    unitgroup autoEE4E8290_g;

    int autoEE4E8290_u;

    unit autoEE4E8290_var;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((libSprt_gv_qACheatsWeaponsDisabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_playerIdx = libGame_gf_HeroSpawnPlayer();

    auto9CF292A2_val = UnitGetType(libGame_gv_players[lv_playerIdx].lv_heroUnit);

    if (auto9CF292A2_val == "HeroLostVikingsController") {

        autoEE4E8290_g = libGame_gv_players[lv_playerIdx].lv_heroUnitGroup;

        autoEE4E8290_u = UnitGroupCount(autoEE4E8290_g, c_unitCountAll);

        for (;; autoEE4E8290_u -= 1) {

            autoEE4E8290_var = UnitGroupUnitFromEnd(autoEE4E8290_g, autoEE4E8290_u);

            if (autoEE4E8290_var == null) { break; }

            UnitBehaviorAddPlayer(autoEE4E8290_var, "DisableWeaponsBehavior", 15, 1);

        }

    }

    else {

        UnitBehaviorAddPlayer(libGame_gv_players[lv_playerIdx].lv_heroUnit, "DisableWeaponsBehavior", 15, 1);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsDisableWeaponsOnSpawn_Init () {

    libSprt_gt_QACheatsDisableWeaponsOnSpawn = TriggerCreate("libSprt_gt_QACheatsDisableWeaponsOnSpawn_Func");

    libGame_gf_HeroSpawn(libSprt_gt_QACheatsDisableWeaponsOnSpawn);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Disable Weapons On Chen Ult

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsDisableWeaponsOnChenUlt_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIdx;

    int lv_player;



    // Automatic Variable Declarations

    string autoAB2085A6_val;

    unitgroup autoA7634969_g;

    int autoA7634969_u;

    unit autoA7634969_var;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((libSprt_gv_qACheatsWeaponsDisabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    Wait(1.1, c_timeGame);

    lv_playerIdx = UnitGetOwner(EventUnit());

    autoAB2085A6_val = UnitGetType(libGame_gv_players[lv_playerIdx].lv_heroUnit);

    if (autoAB2085A6_val == "HeroChen") {

        autoA7634969_g = libGame_gv_players[lv_playerIdx].lv_heroUnitGroup;

        autoA7634969_u = UnitGroupCount(autoA7634969_g, c_unitCountAll);

        for (;; autoA7634969_u -= 1) {

            autoA7634969_var = UnitGroupUnitFromEnd(autoA7634969_g, autoA7634969_u);

            if (autoA7634969_var == null) { break; }

            UnitBehaviorAddPlayer(autoA7634969_var, "DisableWeaponsBehavior", 15, 1);

        }

    }

    else {

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsDisableWeaponsOnChenUlt_Init () {

    libSprt_gt_QACheatsDisableWeaponsOnChenUlt = TriggerCreate("libSprt_gt_QACheatsDisableWeaponsOnChenUlt_Func");

    TriggerAddEventUnitAbility(libSprt_gt_QACheatsDisableWeaponsOnChenUlt, null, AbilityCommand("ChenStormEarthFire", 0), c_unitAbilStageAll, false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Unit Selected

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsUnitSelected_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((DialogIsVisible(libSprt_gv_qACheatsControlsPanel.lv_mainDialog, EventPlayer()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_qACheatsSelectedUnit = EventUnit();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsUnitSelected_Init () {

    libSprt_gt_QACheatsUnitSelected = TriggerCreate("libSprt_gt_QACheatsUnitSelected_Func");

    TriggerAddEventUnitSelected(libSprt_gt_QACheatsUnitSelected, null, c_playerAny, true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Behavior Dropdown Selection Change

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsBehaviorDropdownSelectionChange_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_heroIndex;

    int lv_triggeringPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_triggeringPlayer = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_behaviorListPulldown))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_qACheatsSelectedBehavior = DialogControlGetSelectedItem(EventDialogControl(), lv_triggeringPlayer);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsBehaviorDropdownSelectionChange_Init () {

    libSprt_gt_QACheatsBehaviorDropdownSelectionChange = TriggerCreate("libSprt_gt_QACheatsBehaviorDropdownSelectionChange_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsBehaviorDropdownSelectionChange, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeSelectionChanged);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Behavior Apply Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsBehaviorApplyButtonClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_behaviorApplyButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorAdd(libSprt_gv_qACheatsSelectedUnit, (libSprt_gv_compiledBehaviorList[libSprt_gv_qACheatsSelectedBehavior]), libSprt_gv_qACheatsSelectedUnit, 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsBehaviorApplyButtonClicked_Init () {

    libSprt_gt_QACheatsBehaviorApplyButtonClicked = TriggerCreate("libSprt_gt_QACheatsBehaviorApplyButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsBehaviorApplyButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Behavior Remove Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsBehaviorRemoveButtonClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_behaviorRemoveButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(libSprt_gv_qACheatsSelectedUnit, (libSprt_gv_compiledBehaviorList[libSprt_gv_qACheatsSelectedBehavior]), 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsBehaviorRemoveButtonClicked_Init () {

    libSprt_gt_QACheatsBehaviorRemoveButtonClicked = TriggerCreate("libSprt_gt_QACheatsBehaviorRemoveButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsBehaviorRemoveButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Behavior Cleanse Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsBehaviorCleanseButtonClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_behaviorCleanseButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_QACheatsCleanseAllEffects();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsBehaviorCleanseButtonClicked_Init () {

    libSprt_gt_QACheatsBehaviorCleanseButtonClicked = TriggerCreate("libSprt_gt_QACheatsBehaviorCleanseButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsBehaviorCleanseButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Execute Speed Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsExecuteSpeedButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_speedEditBoxContents;

    fixed lv_speedValue;

    int lv_i;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_speedEditBoxContents = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_executeSpeedButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_speedEditBoxContents = libNtve_gf_DialogItemEditValue(libSprt_gv_qACheatsControlsPanel.lv_speedCountEditbox, 1);

    lv_speedValue = StringToFixed(lv_speedEditBoxContents);

    if ((lv_speedValue > 8.0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F697F4C7"), true);

    }

    else {

        ConsoleCommand(("speed " + lv_speedEditBoxContents), true, true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsExecuteSpeedButtonClicked_Init () {

    libSprt_gt_QACheatsExecuteSpeedButtonClicked = TriggerCreate("libSprt_gt_QACheatsExecuteSpeedButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsExecuteSpeedButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Spawn Units Dropdown Selection Change

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_heroIndex;

    int lv_triggeringPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_triggeringPlayer = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_spawnUnitListPulldown))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_qACheatsSelectedSpawnUnit = DialogControlGetSelectedItem(EventDialogControl(), lv_triggeringPlayer);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange_Init () {

    libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange = TriggerCreate("libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeSelectionChanged);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Team Checkboxes Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsTeamCheckboxesClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!(((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox) || (EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox) && (libNtve_gf_DialogItemIsChecked(EventDialogControl(), EventPlayer()) == true))) {

        libSprt_gv_qACheatsSelectedTeam = 11;

        libNtve_gf_SetDialogItemChecked(libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox, false, PlayerGroupAll());

    }

    else if (((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox) && (libNtve_gf_DialogItemIsChecked(EventDialogControl(), EventPlayer()) == true))) {

        libSprt_gv_qACheatsSelectedTeam = 12;

        libNtve_gf_SetDialogItemChecked(libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox, false, PlayerGroupAll());

    }

    else if (((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_neutralCheckbox) && (libNtve_gf_DialogItemIsChecked(EventDialogControl(), EventPlayer()) == true))) {

        libSprt_gv_qACheatsSelectedTeam = 15;

        libNtve_gf_SetDialogItemChecked(libSprt_gv_qACheatsControlsPanel.lv_orderCheckbox, false, PlayerGroupAll());

        libNtve_gf_SetDialogItemChecked(libSprt_gv_qACheatsControlsPanel.lv_chaosCheckbox, false, PlayerGroupAll());

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsTeamCheckboxesClicked_Init () {

    libSprt_gt_QACheatsTeamCheckboxesClicked = TriggerCreate("libSprt_gt_QACheatsTeamCheckboxesClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsTeamCheckboxesClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Spawn Units Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsSpawnUnitsButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    point lv_currentPos;

    int lv_yOffset;

    unit lv_unitGroupUnit;



    // Automatic Variable Declarations

    unitgroup auto5137A002_g;

    int auto5137A002_u;

    int autoB3597D15_val;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_spawnUnitButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_qACheatsSelectedTeam == 0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_90FB30EE"), true);

    }

    else {

        auto5137A002_g = libSprt_gv_qACheatsSpawnedUnitsGroup;

        auto5137A002_u = UnitGroupCount(auto5137A002_g, c_unitCountAll);

        for (;; auto5137A002_u -= 1) {

            lv_unitGroupUnit = UnitGroupUnitFromEnd(auto5137A002_g, auto5137A002_u);

            if (lv_unitGroupUnit == null) { break; }

            UnitRemove(lv_unitGroupUnit);

        }

        lv_currentPos = CameraGetTarget(EventPlayer());

        autoB3597D15_val = libSprt_gv_qACheatsSelectedSpawnUnit;

        if (autoB3597D15_val == 1) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "FootmanMinion", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, -6.0, -5.0), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "MercDefenderSiegeGiant", 0, libCore_gv_cOMPUTER_Hostile, PointWithOffset(lv_currentPos, 0.0, -5.0), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "MercSummonerLaner", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 6.0, -5.0), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "SkeletalPirate", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, -3.0, -2.5), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "AbathurLocustNormal", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 3.0, -2.5), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            UnitBehaviorRemove(UnitLastCreated(), "LocustTimedLife", 1);

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "JungleGraveGolemLaner", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, -5.0, 5.0), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "VolskayaVehicle", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 5.0, 5.0), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 2) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "FootmanMinion", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 3) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "AbathurLocust", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, -3.0, -2.5), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

            UnitBehaviorRemove(UnitLastCreated(), "LocustTimedLife", 1);

        }

        else if (autoB3597D15_val == 4) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "MercDefenderSiegeGiant", 0, libCore_gv_cOMPUTER_Hostile, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 5) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "MercSummonerLaner", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 6) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "JungleGraveGolemLaner", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 7) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "SkeletalPirate", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 8) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "TownCannonTowerL2", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 9) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "TownTownHallL2", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 10) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "TownTownHallL3", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 11) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "VolskayaVehicle", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else if (autoB3597D15_val == 12) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "TargetHeroDummyFreddie", 0, libSprt_gv_qACheatsSelectedTeam, PointWithOffset(lv_currentPos, 0.0, lv_yOffset), null);

            UnitGroupAdd(libSprt_gv_qACheatsSpawnedUnitsGroup, UnitLastCreated());

        }

        else {

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_A122DB1E"), true);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsSpawnUnitsButtonClicked_Init () {

    libSprt_gt_QACheatsSpawnUnitsButtonClicked = TriggerCreate("libSprt_gt_QACheatsSpawnUnitsButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsSpawnUnitsButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Debug Kill Unit Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsDebugKillUnitButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_debugKillButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_qACheatsSelectedUnit != null)) {

        UnitKill(libSprt_gv_qACheatsSelectedUnit);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsDebugKillUnitButtonClicked_Init () {

    libSprt_gt_QACheatsDebugKillUnitButtonClicked = TriggerCreate("libSprt_gt_QACheatsDebugKillUnitButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsDebugKillUnitButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Refresh Unit Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsRefreshUnitButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_refreshUnitButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_qACheatsSelectedUnit != null)) {

        UnitSetPropertyFixed(libSprt_gv_qACheatsSelectedUnit, c_unitPropLifePercent, 100.0);

        UnitSetPropertyFixed(libSprt_gv_qACheatsSelectedUnit, c_unitPropEnergyPercent, 100.0);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsRefreshUnitButtonClicked_Init () {

    libSprt_gt_QACheatsRefreshUnitButtonClicked = TriggerCreate("libSprt_gt_QACheatsRefreshUnitButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsRefreshUnitButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Move Unit Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsMoveUnitButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_moveUnitButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_qACheatsSelectedUnit != null)) {

        UnitSetPosition(libSprt_gv_qACheatsSelectedUnit, CameraGetTarget(EventPlayer()), false);

    }

    else {

        UnitSetPosition(libGame_gv_players[1].lv_heroUnit, CameraGetTarget(EventPlayer()), false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsMoveUnitButtonClicked_Init () {

    libSprt_gt_QACheatsMoveUnitButtonClicked = TriggerCreate("libSprt_gt_QACheatsMoveUnitButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsMoveUnitButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Refresh Cooldowns Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsRefreshCooldownsButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_refreshCooldownsButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_qACheatsSelectedUnit != null)) {

        UnitClearCooldowns(libSprt_gv_qACheatsSelectedUnit, true);

    }

    else {

        UnitClearCooldowns(libGame_gv_players[EventPlayer()].lv_heroUnit, true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsRefreshCooldownsButtonClicked_Init () {

    libSprt_gt_QACheatsRefreshCooldownsButtonClicked = TriggerCreate("libSprt_gt_QACheatsRefreshCooldownsButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsRefreshCooldownsButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Set Camera Angle Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsSetCameraAngleButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_cameraAngleEditBoxContents;

    fixed lv_angleValue;

    fixed lv_defaultCameraAngle;

    int lv_i;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_cameraAngleEditBoxContents = "";

    lv_defaultCameraAngle = 54.0;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_setCameraAngleButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_cameraAngleEditBoxContents = libNtve_gf_DialogItemEditValue(libSprt_gv_qACheatsControlsPanel.lv_cameraAngleEditbox, 1);

    lv_angleValue = StringToFixed(lv_cameraAngleEditBoxContents);

    if (((lv_angleValue > 90.0) || (lv_angleValue < 0.0))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_2BEEC8D3"), true);

        ConsoleCommand(("aoa " + FixedToString(lv_defaultCameraAngle, c_fixedPrecisionAny)), true, true);

    }

    else {

        ConsoleCommand(("aoa " + lv_cameraAngleEditBoxContents), true, true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsSetCameraAngleButtonClicked_Init () {

    libSprt_gt_QACheatsSetCameraAngleButtonClicked = TriggerCreate("libSprt_gt_QACheatsSetCameraAngleButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsSetCameraAngleButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Toggle Debug Camera Checkbox Checked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_toggleDebugCameraCheckbox))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    ConsoleCommand("dc", true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked_Init () {

    libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked = TriggerCreate("libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeChecked);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Spawn Item Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsSpawnItemButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    point lv_currentPos;

    int lv_yOffset;

    string lv_itemCouintEditBoxContents;

    int lv_itemCount;

    int lv_itemOwner;



    // Automatic Variable Declarations

    int autoB40E258C_val;



    // Variable Initialization

    lv_itemCouintEditBoxContents = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_spawnItemButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itemCouintEditBoxContents = libNtve_gf_DialogItemEditValue(libSprt_gv_qACheatsControlsPanel.lv_itemCountEditbox, EventPlayer());

    lv_itemCount = StringToInt(lv_itemCouintEditBoxContents);

    lv_currentPos = CameraGetTarget(EventPlayer());

    lv_itemOwner = libGame_gf_ComputerPlayerInTeam(EventPlayer());

    autoB40E258C_val = DialogControlGetSelectedItem(libSprt_gv_qACheatsControlsPanel.lv_spawnItemListPulldown, EventPlayer());

    if (autoB40E258C_val == 1) {

        libNtve_gf_CreateUnitsWithDefaultFacing(lv_itemCount, "RegenGlobeNeutral", 0, 1, lv_currentPos, null);

    }

    else if (autoB40E258C_val == 2) {

        libNtve_gf_CreateUnitsWithDefaultFacing(lv_itemCount, "ItemSeedPickup", 0, 1, lv_currentPos, null);

    }

    else if (autoB40E258C_val == 3) {

        libNtve_gf_CreateUnitsWithDefaultFacing(lv_itemCount, "ItemUnderworldPowerup", 0, 1, lv_currentPos, null);

    }

    else if (autoB40E258C_val == 4) {

        libNtve_gf_CreateUnitsWithDefaultFacing(lv_itemCount, "ItemCannonball", 0, 1, lv_currentPos, null);

    }

    else if (autoB40E258C_val == 5) {

        libNtve_gf_CreateUnitsWithDefaultFacing(lv_itemCount, "ExperienceGlobeMinion", 0, lv_itemOwner, lv_currentPos, null);

    }

    else {

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsSpawnItemButtonClicked_Init () {

    libSprt_gt_QACheatsSpawnItemButtonClicked = TriggerCreate("libSprt_gt_QACheatsSpawnItemButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsSpawnItemButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Respawn Structures Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsRespawnStructuresButtonClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_respawnStructuresButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libSprt_gt_DEBUGRespawnStructures, true, false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsRespawnStructuresButtonClicked_Init () {

    libSprt_gt_QACheatsRespawnStructuresButtonClicked = TriggerCreate("libSprt_gt_QACheatsRespawnStructuresButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsRespawnStructuresButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Kill Structures Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsKillStructuresButtonClicked_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_killStructuresButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libSprt_gt_DEBUGKillStructures, true, false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsKillStructuresButtonClicked_Init () {

    libSprt_gt_QACheatsKillStructuresButtonClicked = TriggerCreate("libSprt_gt_QACheatsKillStructuresButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsKillStructuresButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: QA Cheats - Debug Respawn Button Clicked

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_QACheatsDebugRespawnButtonClicked_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    string autoA9992419_val;

    unitgroup autoD4C1F5DA_g;

    int autoD4C1F5DA_u;

    unit autoD4C1F5DA_var;



    // Variable Initialization

    lv_player = 1;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((EventDialogControl() == libSprt_gv_qACheatsControlsPanel.lv_debugRespawnButton))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    autoA9992419_val = UnitGetType(libGame_gv_players[lv_player].lv_heroUnit);

    if (autoA9992419_val == "HeroLostVikingsController") {

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_erikDeathTimer, 0.01, false, c_timeGame);

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_baleogDeathTimer, 0.01, false, c_timeGame);

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_olafDeathTimer, 0.01, false, c_timeGame);

        Wait(0.0625, c_timeGame);

        autoD4C1F5DA_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        autoD4C1F5DA_u = UnitGroupCount(autoD4C1F5DA_g, c_unitCountAll);

        for (;; autoD4C1F5DA_u -= 1) {

            autoD4C1F5DA_var = UnitGroupUnitFromEnd(autoD4C1F5DA_g, autoD4C1F5DA_u);

            if (autoD4C1F5DA_var == null) { break; }

            UnitSetPosition(autoD4C1F5DA_var, CameraGetTarget(EventPlayer()), false);

        }

    }

    else if (autoA9992419_val == "HeroLeoric") {

        UnitBehaviorRemove(libGame_gv_players[lv_player].lv_heroUnit, "LeoricUndying", 1);

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

        Wait(0.0625, c_timeGame);

        UnitSetPosition(libGame_gv_players[lv_player].lv_heroUnit, CameraGetTarget(EventPlayer()), false);

    }

    else if (autoA9992419_val == "HeroGall") {

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

    }

    else {

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

        Wait(0.0625, c_timeGame);

        UnitSetPosition(libGame_gv_players[lv_player].lv_heroUnit, CameraGetTarget(EventPlayer()), false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_QACheatsDebugRespawnButtonClicked_Init () {

    libSprt_gt_QACheatsDebugRespawnButtonClicked = TriggerCreate("libSprt_gt_QACheatsDebugRespawnButtonClicked_Func");

    TriggerAddEventDialogControl(libSprt_gt_QACheatsDebugRespawnButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Intro VO Interactor Item (introvotest)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGIntroVOInteractorItemintrovotest_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_unit;

    unitgroup lv_unitGroup;

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_unitGroup = UnitGroupEmpty();

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 1) != "introvotest")) {

        return true;

    }

    else {

        lv_unit = UnitGroupUnit(UnitGroupSelected(lv_player), 1);

        lv_unitGroup = UnitGroupSelected(lv_player);

        UnitBehaviorAdd(libAIAI_gv_aIHeroes[lv_player].lv_currentHeroUnit, "IntroVOInteractor", libAIAI_gv_aIHeroes[lv_player].lv_currentHeroUnit, 1);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGIntroVOInteractorItemintrovotest_Init () {

    libSprt_gt_DEBUGIntroVOInteractorItemintrovotest = TriggerCreate("libSprt_gt_DEBUGIntroVOInteractorItemintrovotest_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGIntroVOInteractorItemintrovotest, c_playerAny, "introvotest", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Intro VO Interactor Usage

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGIntroVOInteractorUsage_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_triggeringPlayer;

    int lv_targetPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_triggeringPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));

    lv_targetPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitTarget));



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((lv_triggeringPlayer > 0) && (lv_triggeringPlayer < libCore_gv_bALMaxPlayers) && (lv_targetPlayer > 0) && (lv_targetPlayer < libCore_gv_bALMaxPlayers))) {

        libCore_gf_DataHeroVOReloadHeroVODataForHero(lv_triggeringPlayer);

        libCore_gf_DataHeroVOReloadHeroVODataForHero(lv_targetPlayer);

        libSond_gf_HeroVOPlayHeroIntroLinesForPlayer(lv_triggeringPlayer, lv_targetPlayer);

        SoundChannelMute(PlayerGroupAll(), c_soundCategoryVoice, true);

        Wait(5.0, c_timeGame);

        SoundChannelMute(PlayerGroupAll(), c_soundCategoryVoice, false);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_967DBBAA"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGIntroVOInteractorUsage_Init () {

    libSprt_gt_DEBUGIntroVOInteractorUsage = TriggerCreate("libSprt_gt_DEBUGIntroVOInteractorUsage_Func");

    TriggerAddEventPlayerEffectUsed(libSprt_gt_DEBUGIntroVOInteractorUsage, c_playerAny, "IntroVOInteractorItemDummy");

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Inspect The Balance Probe (balanceprobe)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;

    int lv_probeScore;



    // Automatic Variable Declarations

    const int autoCA64475E_ae = libCore_gv_bALMaxPlayers;

    const int autoCA64475E_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itPlayer = 1;

    for ( ; ( (autoCA64475E_ai >= 0 && lv_itPlayer <= autoCA64475E_ae) || (autoCA64475E_ai < 0 && lv_itPlayer >= autoCA64475E_ae) ) ; lv_itPlayer += autoCA64475E_ai ) {

        lv_probeScore = PlayerScoreValueGetAsInt(lv_itPlayer, "BalanceProbe");

        if ((lv_probeScore > 0)) {

            TextExpressionSetToken("Param/Expression/lib_Sprt_93078D24", "A", IntToText(lv_itPlayer));

            TextExpressionSetToken("Param/Expression/lib_Sprt_93078D24", "B", IntToText(lv_probeScore));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_93078D24"), true);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe_Init () {

    libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe = TriggerCreate("libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe, c_playerAny, "balanceprobe", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Reset The Balance Probe (balancereset)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGResetTheBalanceProbebalancereset_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto2A10C238_ae = libCore_gv_bALMaxPlayers;

    const int auto2A10C238_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_D45E8DF9"), true);

    lv_itPlayer = 1;

    for ( ; ( (auto2A10C238_ai >= 0 && lv_itPlayer <= auto2A10C238_ae) || (auto2A10C238_ai < 0 && lv_itPlayer >= auto2A10C238_ae) ) ; lv_itPlayer += auto2A10C238_ai ) {

        PlayerScoreValueSetFromInt(lv_itPlayer, "BalanceProbe", 0);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGResetTheBalanceProbebalancereset_Init () {

    libSprt_gt_DEBUGResetTheBalanceProbebalancereset = TriggerCreate("libSprt_gt_DEBUGResetTheBalanceProbebalancereset_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGResetTheBalanceProbebalancereset, c_playerAny, "balancereset", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Timed Balance Probe (balancetimer)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTimedBalanceProbebalancetimer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;

    string lv_durationString;

    fixed lv_duration;



    // Automatic Variable Declarations

    const int autoFF35C5E8_ae = libCore_gv_bALMaxPlayers;

    const int autoFF35C5E8_ai = 1;



    // Variable Initialization

    lv_durationString = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_durationString = StringWord(EventChatMessage(false), 2);

    if ((lv_durationString == "")) {

        return true;

    }



    lv_duration = StringToFixed(lv_durationString);

    if ((lv_duration <= 0.0)) {

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Sprt_C220AFA1", "A", FixedToText(lv_duration, 3));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_C220AFA1"), true);

    lv_itPlayer = 1;

    for ( ; ( (autoFF35C5E8_ai >= 0 && lv_itPlayer <= autoFF35C5E8_ae) || (autoFF35C5E8_ai < 0 && lv_itPlayer >= autoFF35C5E8_ae) ) ; lv_itPlayer += autoFF35C5E8_ai ) {

        PlayerScoreValueSetFromInt(lv_itPlayer, "BalanceProbe", 0);

    }

    libSprt_gv_dEBUGBalanceProbeTimerDuration = lv_duration;

    TimerStart(libSprt_gv_dEBUGBalanceProbeTimer, lv_duration, false, c_timeGame);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTimedBalanceProbebalancetimer_Init () {

    libSprt_gt_DEBUGTimedBalanceProbebalancetimer = TriggerCreate("libSprt_gt_DEBUGTimedBalanceProbebalancetimer_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTimedBalanceProbebalancetimer, c_playerAny, "balancetimer", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Balance Probe Timer Expires

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGBalanceProbeTimerExpires_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto85FD5875_ae = libCore_gv_bALMaxPlayers;

    const int auto85FD5875_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_69378B97"), true);

    lv_itPlayer = 1;

    for ( ; ( (auto85FD5875_ai >= 0 && lv_itPlayer <= auto85FD5875_ae) || (auto85FD5875_ai < 0 && lv_itPlayer >= auto85FD5875_ae) ) ; lv_itPlayer += auto85FD5875_ai ) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_92FCDA60", "A", IntToText(lv_itPlayer));

        TextExpressionSetToken("Param/Expression/lib_Sprt_92FCDA60", "B", FixedToText((PlayerScoreValueGetAsInt(lv_itPlayer, "BalanceProbe") / libSprt_gv_dEBUGBalanceProbeTimerDuration), 3));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_92FCDA60"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGBalanceProbeTimerExpires_Init () {

    libSprt_gt_DEBUGBalanceProbeTimerExpires = TriggerCreate("libSprt_gt_DEBUGBalanceProbeTimerExpires_Func");

    TriggerAddEventTimer(libSprt_gt_DEBUGBalanceProbeTimerExpires, libSprt_gv_dEBUGBalanceProbeTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Enable Sound Repeat

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGEnableSoundRepeat_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_soundRepeatActive == false)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_7CB411CC"), true);

        libSprt_gv_soundRepeatActive = true;

        libSprt_gf_DEBUGSoundRepeatRepeatSound();

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_75796628"), true);

        libSprt_gv_soundRepeatActive = false;

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGEnableSoundRepeat_Init () {

    libSprt_gt_DEBUGEnableSoundRepeat = TriggerCreate("libSprt_gt_DEBUGEnableSoundRepeat_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEnableSoundRepeat, c_playerAny, "-soundrepeat", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sound Repeat - Adjust Delay

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSoundRepeatAdjustDelay_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_delay;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_soundRepeatActive == true)) {

        lv_delay = StringToFixed(StringSub(EventChatMessage(false), 19, 20));

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_973E5B42") + (FixedToText(lv_delay, c_fixedPrecisionAny) + StringExternal("Param/Value/lib_Sprt_3F1EBAED"))), true);

        libSprt_gv_soundRepeatDelay = lv_delay;

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSoundRepeatAdjustDelay_Init () {

    libSprt_gt_DEBUGSoundRepeatAdjustDelay = TriggerCreate("libSprt_gt_DEBUGSoundRepeatAdjustDelay_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSoundRepeatAdjustDelay, c_playerAny, "-soundrepeatdelay", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sound Repeat - Ability Used

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSoundRepeatAbilityUsed_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((libSprt_gv_soundRepeatActive == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_soundRepeatCurrentAbility = AbilityCommandGetAbility(EventUnitAbility());

    libSprt_gv_soundRepeatCasterUnit = EventUnit();

    libSprt_gv_soundRepeatTargetUnit = EventUnit();

    libSprt_gv_soundRepeatTargetPoint = EventUnitTargetPoint();

    TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_70320A3A") + StringToText((libSprt_gv_soundRepeatCurrentAbility))), true);

    TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_03F004D0") + UnitTypeGetName(UnitGetType(EventUnit()))), true);

    TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_5AEA6C15") + libCore_gf_ConvertPointToText(EventUnitTargetPoint())), true);

    if ((EventUnitTargetUnit() != null)) {

        libSprt_gv_soundRepeatTargetUnit = EventUnitTargetUnit();

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_890B3BA1") + UnitTypeGetName(UnitGetType(EventUnitTargetUnit()))), true);

    }

    else {

        libSprt_gv_soundRepeatTargetUnit = null;

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSoundRepeatAbilityUsed_Init () {

    libSprt_gt_DEBUGSoundRepeatAbilityUsed = TriggerCreate("libSprt_gt_DEBUGSoundRepeatAbilityUsed_Func");

    TriggerAddEventUnitAbility(libSprt_gt_DEBUGSoundRepeatAbilityUsed, null, null, c_abilEffectStageCast, false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Passive Exp Balancer (passivebalance)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGPassiveExpBalancerpassivebalance_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_oldBoostVal;

    int lv_team1Level;

    int lv_team2Level;

    int lv_iterPlayer;

    int lv_iterLevel;



    // Automatic Variable Declarations

    const int autoFBB9BB9E_ae = libCore_gv_bALMaxPlayers;

    const int autoFBB9BB9E_ai = 1;

    const int auto0BAED222_ae = libCore_gv_bALMaxPlayers;

    const int auto0BAED222_ai = 1;

    const int auto6D226E03_ae = 0;

    const int auto6D226E03_ai = -1;

    const int auto277E1E09_ae = 0;

    const int auto277E1E09_ai = -1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPPassiveBalancerEnable = !(libSprt_gv_dEBUGXPPassiveBalancerEnable);

    if ((libSprt_gv_dEBUGXPPassiveBalancerEnable == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_5ADEFA28"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_62E146FA"), true);

    }

    lv_iterPlayer = 1;

    for ( ; ( (autoFBB9BB9E_ai >= 0 && lv_iterPlayer <= autoFBB9BB9E_ae) || (autoFBB9BB9E_ai < 0 && lv_iterPlayer >= autoFBB9BB9E_ae) ) ; lv_iterPlayer += autoFBB9BB9E_ai ) {

        if ((libGame_gf_TeamNumberOfPlayer(lv_iterPlayer) == 1)) {

            libSprt_gv_dEBUGXPPassiveBalancerTeam1Player = lv_iterPlayer;

            break;

        }



    }

    lv_iterPlayer = 1;

    for ( ; ( (auto0BAED222_ai >= 0 && lv_iterPlayer <= auto0BAED222_ae) || (auto0BAED222_ai < 0 && lv_iterPlayer >= auto0BAED222_ae) ) ; lv_iterPlayer += auto0BAED222_ai ) {

        if ((libGame_gf_TeamNumberOfPlayer(lv_iterPlayer) == 2)) {

            libSprt_gv_dEBUGXPPassiveBalancerTeam2Player = lv_iterPlayer;

            break;

        }



    }

    while ((libSprt_gv_dEBUGXPPassiveBalancerEnable == true)) {

        lv_oldBoostVal = libSprt_gv_dEBUGXPPassiveBoostMultiplier;

        libSprt_gv_dEBUGXPPassiveBoostMultiplier = 1.0;

        lv_team1Level = UnitXPGetCurrentLevel(libGame_gv_players[libSprt_gv_dEBUGXPPassiveBalancerTeam1Player].lv_heroUnit, null);

        lv_team2Level = UnitXPGetCurrentLevel(libGame_gv_players[libSprt_gv_dEBUGXPPassiveBalancerTeam2Player].lv_heroUnit, null);

        if ((lv_team1Level != lv_team2Level)) {

            if ((lv_team1Level > lv_team2Level)) {

                lv_iterLevel = (lv_team1Level - lv_team2Level);

                for ( ; ( (auto277E1E09_ai >= 0 && lv_iterLevel <= auto277E1E09_ae) || (auto277E1E09_ai < 0 && lv_iterLevel >= auto277E1E09_ae) ) ; lv_iterLevel += auto277E1E09_ai ) {

                    libSprt_gv_dEBUGXPPassiveBoostMultiplier = (libSprt_gv_dEBUGXPPassiveBoostMultiplier + (IntToFixed(lv_iterLevel) * 0.1));

                }

                libSprt_gv_dEBUGXPPassiveBoostTeam = libGame_gf_TeamNumberOfPlayer(libSprt_gv_dEBUGXPPassiveBalancerTeam2Player);

            }

            else {

                lv_iterLevel = (lv_team2Level - lv_team1Level);

                for ( ; ( (auto6D226E03_ai >= 0 && lv_iterLevel <= auto6D226E03_ae) || (auto6D226E03_ai < 0 && lv_iterLevel >= auto6D226E03_ae) ) ; lv_iterLevel += auto6D226E03_ai ) {

                    libSprt_gv_dEBUGXPPassiveBoostMultiplier = (libSprt_gv_dEBUGXPPassiveBoostMultiplier + (IntToFixed(lv_iterLevel) * 0.1));

                }

                libSprt_gv_dEBUGXPPassiveBoostTeam = libGame_gf_TeamNumberOfPlayer(libSprt_gv_dEBUGXPPassiveBalancerTeam1Player);

            }

        }



        if ((lv_oldBoostVal != libSprt_gv_dEBUGXPPassiveBoostMultiplier)) {

        }



        Wait(1.0, c_timeGame);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGPassiveExpBalancerpassivebalance_Init () {

    libSprt_gt_DEBUGPassiveExpBalancerpassivebalance = TriggerCreate("libSprt_gt_DEBUGPassiveExpBalancerpassivebalance_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPassiveExpBalancerpassivebalance, c_playerAny, "passivebalance", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Which players are AI? (whoisai)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGWhichplayersareAIwhoisai_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    int auto550C5206_ae;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto550C5206_ae = libCore_gv_bALMaxPlayers;

    lv_itPlayer = 1;

    for ( ; lv_itPlayer <= auto550C5206_ae ; lv_itPlayer += 1 ) {

        if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_itPlayer) == true)) {

            TextExpressionSetToken("Param/Expression/lib_Sprt_B480E703", "A", IntToText(lv_itPlayer));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_B480E703"), true);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGWhichplayersareAIwhoisai_Init () {

    libSprt_gt_DEBUGWhichplayersareAIwhoisai = TriggerCreate("libSprt_gt_DEBUGWhichplayersareAIwhoisai_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGWhichplayersareAIwhoisai, c_playerAny, "whoisai", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Equalize Experience (eqxp)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGEqualizeExperienceeqxp_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_iterPlayer;

    fixed lv_highestXP;



    // Automatic Variable Declarations

    int auto1BAA646D_ae;

    int autoBE69E612_ae;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!(((StringWord(EventChatMessage(false), 1) == "eqexp") || (StringWord(EventChatMessage(false), 1) == "eqxp")))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto1BAA646D_ae = libCore_gv_bALMaxPlayers;

    lv_iterPlayer = 1;

    for ( ; lv_iterPlayer <= auto1BAA646D_ae ; lv_iterPlayer += 1 ) {

        if ((UnitIsValid(libGame_gv_players[lv_iterPlayer].lv_heroUnit) == true)) {

            if ((UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit) > lv_highestXP)) {

                lv_highestXP = UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit);

            }



        }



    }

    autoBE69E612_ae = libCore_gv_bALMaxPlayers;

    lv_iterPlayer = 1;

    for ( ; lv_iterPlayer <= autoBE69E612_ae ; lv_iterPlayer += 1 ) {

        if ((UnitIsValid(libGame_gv_players[lv_iterPlayer].lv_heroUnit) == true)) {

            UnitXPSetCurrentXP(libGame_gv_players[lv_iterPlayer].lv_heroUnit, "HeroDummyVeterancy", lv_highestXP);

        }



    }

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_10EDD58B"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGEqualizeExperienceeqxp_Init () {

    libSprt_gt_DEBUGEqualizeExperienceeqxp = TriggerCreate("libSprt_gt_DEBUGEqualizeExperienceeqxp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEqualizeExperienceeqxp, c_playerAny, "eqexp", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEqualizeExperienceeqxp, c_playerAny, "eqxp", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Boost Experience (eqexpboost)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGBoostExperienceeqexpboost_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_highestXPUnit;

    unit lv_lowestXPUnit;

    fixed lv_highestXP;

    fixed lv_lowestXP;

    int lv_iterPlayer;



    // Automatic Variable Declarations

    int auto5C858753_ae;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "eqexpboost"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_lowestXP = UnitXPTotal(libGame_gv_players[1].lv_heroUnit);

    auto5C858753_ae = libCore_gv_bALMaxPlayers;

    lv_iterPlayer = 1;

    for ( ; lv_iterPlayer <= auto5C858753_ae ; lv_iterPlayer += 1 ) {

        if ((UnitIsValid(libGame_gv_players[lv_iterPlayer].lv_heroUnit) == true)) {

            if ((UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit) >= lv_highestXP)) {

                lv_highestXP = UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit);

                lv_highestXPUnit = libGame_gv_players[lv_iterPlayer].lv_heroUnit;

            }



            if ((UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit) <= lv_lowestXP)) {

                lv_lowestXP = UnitXPTotal(libGame_gv_players[lv_iterPlayer].lv_heroUnit);

                lv_lowestXPUnit = libGame_gv_players[lv_iterPlayer].lv_heroUnit;

            }



        }



    }

    if ((libSprt_gv_dEBUGXPBoostEnable == true)) {

        libSprt_gv_dEBUGXPBoostEnable = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_9FE291DB"), true);

    }

    else {

        libSprt_gv_dEBUGXPBoostEnable = true;

        if ((UnitXPTotal(lv_highestXPUnit) > UnitXPTotal(lv_lowestXPUnit))) {

            libSprt_gv_dEBUGXPBoostTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lv_lowestXPUnit));

        }



        TextExpressionSetToken("Param/Expression/lib_Sprt_FAFB9CFF", "A", IntToText(libSprt_gv_dEBUGXPBoostTeam));

        TextExpressionSetToken("Param/Expression/lib_Sprt_FAFB9CFF", "B", FixedToText(libSprt_gv_dEBUGXPBoostMultiplier, c_fixedPrecisionAny));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_FAFB9CFF"), true);

    }

    while ((libSprt_gv_dEBUGXPBoostEnable == true)) {

        if ((UnitXPGetCurrentLevel(lv_highestXPUnit, "HeroDummyVeterancy") == UnitXPGetCurrentLevel(lv_lowestXPUnit, "HeroDummyVeterancy"))) {

            libSprt_gv_dEBUGXPBoostEnable = false;

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_4A3E86C3"), true);

            break;

        }



        Wait(1.0, c_timeGame);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGBoostExperienceeqexpboost_Init () {

    libSprt_gt_DEBUGBoostExperienceeqexpboost = TriggerCreate("libSprt_gt_DEBUGBoostExperienceeqexpboost_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGBoostExperienceeqexpboost, c_playerAny, "eqexpboost", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XP Trickle Only (xptrickleonly)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "xptrickleonly"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPTrickleOnly = !(libSprt_gv_dEBUGXPTrickleOnly);

    if ((libSprt_gv_dEBUGXPTrickleOnly == true)) {

        libSprt_gv_dEBUGXPSourceHero = false;

        libSprt_gv_dEBUGXPSourceMinion = false;

        libSprt_gv_dEBUGXPSourceStructure = false;

        libSprt_gv_dEBUGXPSourceCreep = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_30CB3B0B"), true);

    }

    else {

        libSprt_gv_dEBUGXPSourceHero = true;

        libSprt_gv_dEBUGXPSourceMinion = true;

        libSprt_gv_dEBUGXPSourceStructure = true;

        libSprt_gv_dEBUGXPSourceCreep = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F5E9C663"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly_Init () {

    libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly = TriggerCreate("libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly, c_playerAny, "xptrickleonly", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Suppress Debug Messages

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSuppressDebugMessages_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_dEBUGDebugMessagesEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_5C253C81"), true);

        TriggerDebugOutputEnable(false);

        libSprt_gv_dEBUGDebugMessagesEnabled = false;

    }

    else {

        TriggerDebugOutputEnable(true);

        libSprt_gv_dEBUGDebugMessagesEnabled = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_B619AFF5"), true);

    }

    TriggerEnable(TriggerGetCurrent(), false);

    Wait(2.0, c_timeGame);

    TriggerEnable(TriggerGetCurrent(), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSuppressDebugMessages_Init () {

    libSprt_gt_DEBUGSuppressDebugMessages = TriggerCreate("libSprt_gt_DEBUGSuppressDebugMessages_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSuppressDebugMessages, c_playerAny, "SuppressDebug", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XP Hero (xphero)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPHeroxphero_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "xphero"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPSourceHero = !(libSprt_gv_dEBUGXPSourceHero);

    if ((libSprt_gv_dEBUGXPSourceHero == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_CB24D285"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E248D8E6"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPHeroxphero_Init () {

    libSprt_gt_DEBUGXPHeroxphero = TriggerCreate("libSprt_gt_DEBUGXPHeroxphero_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPHeroxphero, c_playerAny, "xphero", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XP Minion (xpminion)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPMinionxpminion_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "xpminion"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPSourceMinion = !(libSprt_gv_dEBUGXPSourceMinion);

    if ((libSprt_gv_dEBUGXPSourceMinion == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F6145551"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_C4646AEC"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPMinionxpminion_Init () {

    libSprt_gt_DEBUGXPMinionxpminion = TriggerCreate("libSprt_gt_DEBUGXPMinionxpminion_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPMinionxpminion, c_playerAny, "xpminion", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XP Structure (xpstructure)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPStructurexpstructure_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "xpstructure"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPSourceStructure = !(libSprt_gv_dEBUGXPSourceStructure);

    if ((libSprt_gv_dEBUGXPSourceStructure == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_EBC77719"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_39D26696"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPStructurexpstructure_Init () {

    libSprt_gt_DEBUGXPStructurexpstructure = TriggerCreate("libSprt_gt_DEBUGXPStructurexpstructure_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPStructurexpstructure, c_playerAny, "xpstructure", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XP Creep (xpcreep)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPCreepxpcreep_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "xpcreep"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGXPSourceCreep = !(libSprt_gv_dEBUGXPSourceCreep);

    if ((libSprt_gv_dEBUGXPSourceCreep == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_98AAB9FB"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E71E43A5"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPCreepxpcreep_Init () {

    libSprt_gt_DEBUGXPCreepxpcreep = TriggerCreate("libSprt_gt_DEBUGXPCreepxpcreep_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPCreepxpcreep, c_playerAny, "xpcreep", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Help (-help)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHelphelp_Func (bool testConds, bool runActions) {

    // Variable Declarations

    text lv_helpText;

    text lv_mapMechanic;



    // Automatic Variable Declarations

    string auto626C8B02_val;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto626C8B02_val = libMapM_gf_PrimaryMapMechanic();

    if (auto626C8B02_val == libMapM_gv_mMRavenMechanicName_C) {

        lv_mapMechanic = StringExternal("Param/Value/lib_Sprt_4F5B164C");

    }

    else if (auto626C8B02_val == libMapM_gv_mMGardensDragonMechanicName_C) {

        lv_mapMechanic = StringExternal("Param/Value/lib_Sprt_6C304C4B");

    }

    else {

    }

    TextExpressionSetToken("Param/Expression/lib_Sprt_B8FC5DE5", "A", StringExternal("Param/Value/lib_Sprt_DBB0F085"));

    TextExpressionSetToken("Param/Expression/lib_Sprt_B8FC5DE5", "B", lv_mapMechanic);

    TextExpressionSetToken("Param/Expression/lib_Sprt_B8FC5DE5", "C", StringExternal("Param/Value/lib_Sprt_E371B151"));

    lv_helpText = TextExpressionAssemble("Param/Expression/lib_Sprt_B8FC5DE5");

    TriggerDebugOutput(1, lv_helpText, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHelphelp_Init () {

    libSprt_gt_DEBUGHelphelp = TriggerCreate("libSprt_gt_DEBUGHelphelp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHelphelp, c_playerAny, "-help", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Player Number (-playernum)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGPlayerNumberplayernum_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Sprt_25AF409F", "A", IntToText(EventPlayer()));

    UIDisplayMessage(libCore_gv_playerGroupFromPlayer[EventPlayer()], c_messageAreaChat, TextExpressionAssemble("Param/Expression/lib_Sprt_25AF409F"));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGPlayerNumberplayernum_Init () {

    libSprt_gt_DEBUGPlayerNumberplayernum = TriggerCreate("libSprt_gt_DEBUGPlayerNumberplayernum_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPlayerNumberplayernum, c_playerAny, "-playernumber", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPlayerNumberplayernum, c_playerAny, "playernumber", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPlayerNumberplayernum, c_playerAny, "-playernum", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPlayerNumberplayernum, c_playerAny, "playernum", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Selection (togselection)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleSelectiontogselection_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DEBUGToggleSelection();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleSelectiontogselection_Init () {

    libSprt_gt_DEBUGToggleSelectiontogselection = TriggerCreate("libSprt_gt_DEBUGToggleSelectiontogselection_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleSelectiontogselection, c_playerAny, "togselection", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleSelectiontogselection, c_playerAny, "ts", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Show XP Values (togshowxpvalues)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_dEBUGXPTextEnabled == false)) {

        libSprt_gv_dEBUGXPTextEnabled = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_3BFE4072"), true);

    }

    else {

        libSprt_gv_dEBUGXPTextEnabled = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_0BD84C43"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues_Init () {

    libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues = TriggerCreate("libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues, c_playerAny, "togshowxpvalues", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Start Game (startgame)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStartGamestartgame_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((DialogControlIsEnabled(libUIUI_gv_uIDebugPanel.lv_startGameButton, EventPlayer()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DEBUGStartGame();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStartGamestartgame_Init () {

    libSprt_gt_DEBUGStartGamestartgame = TriggerCreate("libSprt_gt_DEBUGStartGamestartgame_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStartGamestartgame, c_playerAny, "startgame", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Disable Ping Limit (freepings)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDisablePingLimitfreepings_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto670796E2_g;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libCore_gv_dEBUGPingLimitEnabled == true)) {

        libCore_gv_dEBUGPingLimitEnabled = false;

        auto670796E2_g = PlayerGroupActive();

        lv_itPlayer = -1;

        while (true) {

            	lv_itPlayer = PlayerGroupNextPlayer(auto670796E2_g, lv_itPlayer);

            	if (lv_itPlayer<0) { break; }

            	libUIUI_gf_PingResetPingLockoutTimeandPingCount(lv_itPlayer);

        }

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E9899B58"), true);

    }

    else {

        libCore_gv_dEBUGPingLimitEnabled = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_27933BF2"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDisablePingLimitfreepings_Init () {

    libSprt_gt_DEBUGDisablePingLimitfreepings = TriggerCreate("libSprt_gt_DEBUGDisablePingLimitfreepings_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGDisablePingLimitfreepings, c_playerAny, "freepings", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Pause Game Start Timer (pausestart)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGPauseGameStartTimerpausestart_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((TimerGetRemaining(libGame_gv_openTheGatesTimer) > 0.0)) {

        if ((TimerIsPaused(libGame_gv_openTheGatesTimer) == true)) {

            TimerPause(libGame_gv_openTheGatesTimer, false);

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_8C0D6AED"), true);

        }

        else {

            TimerPause(libGame_gv_openTheGatesTimer, true);

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_5AEB882F"), true);

        }

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGPauseGameStartTimerpausestart_Init () {

    libSprt_gt_DEBUGPauseGameStartTimerpausestart = TriggerCreate("libSprt_gt_DEBUGPauseGameStartTimerpausestart_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGPauseGameStartTimerpausestart, c_playerAny, "pausestart", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Turn On Normal Creep Camps (creepcamp)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((DialogControlIsEnabled(libUIUI_gv_uIDebugPanel.lv_spawnCreepCampsButton, EventPlayer()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DEBUGSpawnCreepCamps();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp_Init () {

    libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp = TriggerCreate("libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp, c_playerAny, "creepcamp", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Respawn Creep Camps (respawncamps)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGRespawnCreepCampsrespawncamps_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itCamp;



    // Automatic Variable Declarations

    int auto79B01A43_ae;

    const int auto79B01A43_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto79B01A43_ae = libMapM_gv_jungleNumberOfCreepCamps;

    lv_itCamp = 1;

    for ( ; ( (auto79B01A43_ai >= 0 && lv_itCamp <= auto79B01A43_ae) || (auto79B01A43_ai < 0 && lv_itCamp >= auto79B01A43_ae) ) ; lv_itCamp += auto79B01A43_ai ) {

        if ((TimerGetRemaining(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepRespawnTimer) > 1) && (TimerGetRemaining(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepBirthTimer) > 1)) {

            TextExpressionSetToken("Param/Expression/lib_Sprt_2A27C727", "A", IntToText(lv_itCamp));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_2A27C727"), true);

            TimerStart(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepRespawnTimer, (libMapM_gv_bALJungleBirthDelay + 1.0), false, c_timeGame);

            TimerStart(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_stateCreepBirthTimer, 1.0, false, c_timeGame);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGRespawnCreepCampsrespawncamps_Init () {

    libSprt_gt_DEBUGRespawnCreepCampsrespawncamps = TriggerCreate("libSprt_gt_DEBUGRespawnCreepCampsrespawncamps_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGRespawnCreepCampsrespawncamps, c_playerAny, "respawncamps", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Spawn Hero (spawnhero)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSpawnHerospawnhero_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_chatString;

    string lv_hero;

    int lv_heroIndex;

    int lv_player;

    int lv_level;

    fixed lv_xP;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_chatString = "";

    lv_hero = "";

    lv_level = 1;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 1) != "sh") && (StringWord(EventChatMessage(false), 1) != "spawnhero")) {

        return true;

    }



    lv_chatString = StringWord(EventChatMessage(false), 2);

    lv_hero = StringReplaceWord(lv_chatString, "Hero", "", c_stringReplaceAll, c_stringNoCase);

    lv_heroIndex = libCore_gf_GetIndexFromHero((lv_hero));

    lv_player = StringToInt(StringWord(EventChatMessage(false), 3));

    if ((StringWord(EventChatMessage(false), 4) != null)) {

        lv_level = StringToInt(StringWord(EventChatMessage(false), 4));

        lv_xP = libCore_gf_GetTotalXPForLevel(lv_level);

    }



    if ((lv_heroIndex == 0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_3A7EE5DF"), true);

        return true;

    }



    if (((lv_player <= 0) || (lv_player > libCore_gv_bALMaxEnginePlayerCount))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_ECB650C9"), true);

        return true;

    }



    libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(lv_heroIndex, 1, 1, lv_xP, lv_player, EventPlayer());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSpawnHerospawnhero_Init () {

    libSprt_gt_DEBUGSpawnHerospawnhero = TriggerCreate("libSprt_gt_DEBUGSpawnHerospawnhero_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSpawnHerospawnhero, c_playerAny, "spawnhero", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSpawnHerospawnhero, c_playerAny, "sh", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Respawn Hero (debugrespawn)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGRespawnHerodebugrespawn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    string autoF7DD28FB_val;

    unitgroup auto332BEFDE_g;

    int auto332BEFDE_u;

    unit auto332BEFDE_var;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 1) != "debugrespawn")) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) == null)) {

        lv_player = EventPlayer();

    }

    else {

        lv_player = StringToInt(StringWord(EventChatMessage(false), 2));

    }

    if (((libGame_gv_players[lv_player].lv_heroUnit == null) || (lv_player < 1) || (lv_player > 10))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_71113EF8"), true);

        return true;

    }



    autoF7DD28FB_val = UnitGetType(libGame_gv_players[lv_player].lv_heroUnit);

    if (autoF7DD28FB_val == "HeroLostVikingsController") {

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_erikDeathTimer, 0.01, false, c_timeGame);

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_baleogDeathTimer, 0.01, false, c_timeGame);

        TimerStart(libGDHL_gv_lostVikingsPlayer[lv_player].lv_olafDeathTimer, 0.01, false, c_timeGame);

        Wait(0.0625, c_timeGame);

        auto332BEFDE_g = libGame_gv_players[lv_player].lv_heroUnitGroup;

        auto332BEFDE_u = UnitGroupCount(auto332BEFDE_g, c_unitCountAll);

        for (;; auto332BEFDE_u -= 1) {

            auto332BEFDE_var = UnitGroupUnitFromEnd(auto332BEFDE_g, auto332BEFDE_u);

            if (auto332BEFDE_var == null) { break; }

            UnitSetPosition(auto332BEFDE_var, CameraGetTarget(EventPlayer()), false);

        }

    }

    else if (autoF7DD28FB_val == "HeroLeoric") {

        UnitBehaviorRemove(libGame_gv_players[lv_player].lv_heroUnit, "LeoricUndying", 1);

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

        Wait(0.0625, c_timeGame);

        UnitSetPosition(libGame_gv_players[lv_player].lv_heroUnit, CameraGetTarget(EventPlayer()), false);

    }

    else if (autoF7DD28FB_val == "HeroGall") {

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

    }

    else {

        libGame_gf_HeroDeathStartRespawnTimer(lv_player, 0.0);

        Wait(0.0625, c_timeGame);

        UnitSetPosition(libGame_gv_players[lv_player].lv_heroUnit, CameraGetTarget(EventPlayer()), false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGRespawnHerodebugrespawn_Init () {

    libSprt_gt_DEBUGRespawnHerodebugrespawn = TriggerCreate("libSprt_gt_DEBUGRespawnHerodebugrespawn_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGRespawnHerodebugrespawn, c_playerAny, "debugrespawn", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Select Hero (debugselect)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSelectHerodebugselect_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_debugplayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 1) != "debugselect")) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) == null)) {

        lv_debugplayer = EventPlayer();

    }

    else {

        lv_debugplayer = StringToInt(StringWord(EventChatMessage(false), 2));

    }

    if (((libGame_gv_players[lv_debugplayer].lv_heroUnit == null) || (lv_debugplayer < 1) || (lv_debugplayer > 10))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_1F808C09"), true);

        return true;

    }



    UnitClearSelection(EventPlayer());

    UnitGroupSelect(libGame_gv_players[lv_debugplayer].lv_heroUnitGroup, EventPlayer(), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSelectHerodebugselect_Init () {

    libSprt_gt_DEBUGSelectHerodebugselect = TriggerCreate("libSprt_gt_DEBUGSelectHerodebugselect_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSelectHerodebugselect, c_playerAny, "debugselect", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Kill Hero (debugkill)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGKillHerodebugkill_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup auto721BC485_g;

    int auto721BC485_u;

    unit auto721BC485_var;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 1) != "debugkill")) {

        return true;

    }



    auto721BC485_g = UnitGroupSelected(EventPlayer());

    auto721BC485_u = UnitGroupCount(auto721BC485_g, c_unitCountAll);

    for (;; auto721BC485_u -= 1) {

        auto721BC485_var = UnitGroupUnitFromEnd(auto721BC485_g, auto721BC485_u);

        if (auto721BC485_var == null) { break; }

        UnitSetPropertyFixed(auto721BC485_var, c_unitPropLife, 1.0);

        UnitSetPropertyFixed(auto721BC485_var, c_unitPropShields, 0.0);

        UnitCreateEffectUnit(auto721BC485_var, "KingsCoreWeaponDamage", auto721BC485_var);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGKillHerodebugkill_Init () {

    libSprt_gt_DEBUGKillHerodebugkill = TriggerCreate("libSprt_gt_DEBUGKillHerodebugkill_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGKillHerodebugkill, c_playerAny, "debugkill", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - AI Hero Mimic (heromimic)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAIHeroMimicheromimic_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_0AC1A4E9"), true);

    libSprt_gv_dEBUGHeroMimic = true;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAIHeroMimicheromimic_Init () {

    libSprt_gt_DEBUGAIHeroMimicheromimic = TriggerCreate("libSprt_gt_DEBUGAIHeroMimicheromimic_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAIHeroMimicheromimic, c_playerAny, "heromimic", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - AI Set Hero (sethero)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAISetHerosethero_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_hero;

    int lv_player;

    int lv_heroIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_hero = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_player = StringToInt(StringWord(EventChatMessage(false), 2));

    lv_hero = StringWord(EventChatMessage(false), 3);

    lv_heroIndex = libCore_gf_GetIndexFromHero((lv_hero));

    if ((lv_heroIndex == 0)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_CDF6A5CC") + StringToText(lv_hero)), true);

        return true;

    }



    if ((!(((lv_player > 0) && (lv_player <= libCore_gv_bALMaxPlayers))))) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_31DF781A") + IntToText(lv_player)), true);

        return true;

    }



    if ((libGame_gv_players[lv_player].lv_heroIndex == 0)) {

        libGame_gv_players[lv_player].lv_heroIndex = lv_heroIndex;

        TriggerDebugOutput(1, (StringToText(lv_hero) + StringExternal("Param/Value/lib_Sprt_D31F1B1C") + IntToText(lv_player)), true);

    }

    else {

        libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(lv_heroIndex, 1, 1, 0.0, lv_player, 0);

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_76AC8E49") + IntToText(lv_player) + StringExternal("Param/Value/lib_Sprt_34B092C9") + StringToText(lv_hero) + StringExternal("Param/Value/lib_Sprt_66257F08")), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAISetHerosethero_Init () {

    libSprt_gt_DEBUGAISetHerosethero = TriggerCreate("libSprt_gt_DEBUGAISetHerosethero_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAISetHerosethero, c_playerAny, "sethero", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - AI Set All Hero (setallheroes)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAISetAllHerosetallheroes_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_hero;

    int lv_heroIndex;

    int lv_playerIndex;



    // Automatic Variable Declarations

    int autoD7C14807_ae;



    // Variable Initialization

    lv_hero = "";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_hero = StringWord(EventChatMessage(false), 2);

    lv_heroIndex = libCore_gf_GetIndexFromHero((lv_hero));

    if ((lv_heroIndex == 0)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_C8DD3280") + StringToText(lv_hero)), true);

        return true;

    }



    autoD7C14807_ae = libCore_gv_bALMaxPlayers;

    lv_playerIndex = 1;

    for ( ; lv_playerIndex <= autoD7C14807_ae ; lv_playerIndex += 1 ) {

        if ((libGame_gv_players[lv_playerIndex].lv_heroUnit != null)) {

            libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(lv_heroIndex, 1, 1, 0.0, lv_playerIndex, 0);

            TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_11581D48") + IntToText(lv_playerIndex) + StringExternal("Param/Value/lib_Sprt_B61E89E0") + StringToText(lv_hero) + StringExternal("Param/Value/lib_Sprt_C30CDE5A")), true);

        }

        else {

            libGame_gv_players[lv_playerIndex].lv_heroIndex = lv_heroIndex;

            TriggerDebugOutput(1, (StringToText(lv_hero) + StringExternal("Param/Value/lib_Sprt_B12CF695") + IntToText(lv_playerIndex)), true);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAISetAllHerosetallheroes_Init () {

    libSprt_gt_DEBUGAISetAllHerosetallheroes = TriggerCreate("libSprt_gt_DEBUGAISetAllHerosetallheroes_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAISetAllHerosetallheroes, c_playerAny, "setallheroes", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Log Random Heroes For Player

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGLogRandomHeroesForPlayer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_heroIndex;

    int lv_playerIndex;



    // Automatic Variable Declarations

    int auto7198189B_ae;

    const int auto7198189B_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_playerIndex = StringToInt(StringWord(EventChatMessage(false), 2));

    if ((lv_playerIndex == 0)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_65B029F6") + StringToText(StringWord(EventChatMessage(false), 2))), true);

        return true;

    }



    auto7198189B_ae = libCore_gv_dataHeroesNumberOfHeroes;

    lv_heroIndex = 1;

    for ( ; ( (auto7198189B_ai >= 0 && lv_heroIndex <= auto7198189B_ae) || (auto7198189B_ai < 0 && lv_heroIndex >= auto7198189B_ae) ) ; lv_heroIndex += auto7198189B_ai ) {

        if ((libCore_gf_MetagameDoesPlayerHaveAccessToHero(lv_playerIndex, lv_heroIndex) == true) && ((PlayerType(lv_playerIndex) != c_playerTypeComputer) || (libAIAI_gf_HeroAIAIDifficultyLevelShouldUseHero(lv_playerIndex, lv_heroIndex) == true))) {

            TriggerDebugOutput(1, StringToText(DataTableGetString(true, ("HeroIndex_" + IntToString(lv_heroIndex)))), true);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGLogRandomHeroesForPlayer_Init () {

    libSprt_gt_DEBUGLogRandomHeroesForPlayer = TriggerCreate("libSprt_gt_DEBUGLogRandomHeroesForPlayer_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGLogRandomHeroesForPlayer, c_playerAny, "lograndomheroes", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Level AI Heros (heroxp)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGLevelAIHerosheroxp_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_amount;

    int lv_loopIndex;



    // Automatic Variable Declarations

    const int auto455FE030_ae = libCore_gv_bALMaxPlayers;

    const int auto455FE030_ai = 1;



    // Variable Initialization

    lv_amount = 1000.0;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringLength(StringWord(EventChatMessage(false), 2)) > 1)) {

        lv_amount = StringToInt(StringWord(EventChatMessage(false), 2));

    }



    libUIUI_gv_uIPartyFrameMaxLevelForTeam[libGame_gv_teamOrderIndex_C] = 0;

    libUIUI_gv_uIPartyFrameMaxLevelForTeam[libGame_gv_teamChaosIndex_C] = 0;

    lv_loopIndex = 1;

    for ( ; ( (auto455FE030_ai >= 0 && lv_loopIndex <= auto455FE030_ae) || (auto455FE030_ai < 0 && lv_loopIndex >= auto455FE030_ae) ) ; lv_loopIndex += auto455FE030_ai ) {

        if ((libGame_gv_players[lv_loopIndex].lv_heroUnit != null) && (libAIAI_gv_aIHeroes[lv_loopIndex].lv_aIEnabled == true)) {

            libGame_gf_GrantXPToPlayer(lv_amount, lv_loopIndex, libGame_ge_XPSources_Debug);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGLevelAIHerosheroxp_Init () {

    libSprt_gt_DEBUGLevelAIHerosheroxp = TriggerCreate("libSprt_gt_DEBUGLevelAIHerosheroxp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGLevelAIHerosheroxp, c_playerAny, "heroxp", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Floating Combat Text (togcombattext)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGCombatTextEnabled = !(libSprt_gv_dEBUGCombatTextEnabled);

    if ((libSprt_gv_dEBUGCombatTextEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_7E4733D6"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_9879EAA2"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext_Init () {

    libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext = TriggerCreate("libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext, c_playerAny, "togcombattext", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Minion Spawning (togminionspawn)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_minionSpawningEnabled = !(libGame_gv_minionSpawningEnabled);

    if ((libGame_gv_minionSpawningEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E118941E"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_1BD47B30"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn_Init () {

    libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn = TriggerCreate("libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn, c_playerAny, "togminionspawn", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Minion System Paused (togminionpause)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_minionSystemStarted == true)) {

        libGame_gv_minionSystemPaused = !(libGame_gv_minionSystemPaused);

        if ((libGame_gv_minionSystemPaused == true)) {

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E48DDF62"), true);

            libGame_gf_MinionPauseUnpauseMinionSystem(true);

        }

        else {

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_40639798"), true);

            libGame_gf_MinionPauseUnpauseMinionSystem(false);

        }

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_004C8FD1"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause_Init () {

    libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause = TriggerCreate("libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause, c_playerAny, "togminionpause", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Minion System On/Off (togminionsystem)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem_Func (bool testConds, bool runActions) {

    // Variable Declarations

    bool lv_onOff;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_onOff = !(libGame_gv_minionSystemStarted);

    if ((lv_onOff == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_C61F7599"), true);

        libGame_gf_MinionStartStopMinionSystem(true);

        libGame_gf_MinionStartStopMinionSpawnCycle(true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F311E8CE"), true);

        libGame_gf_MinionStartStopMinionSystem(false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem_Init () {

    libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem = TriggerCreate("libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem, c_playerAny, "togminionsystem", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Minion Bonus XP On/Off

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleMinionBonusXPOnOff_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGBonusMinionXP = !(libSprt_gv_dEBUGBonusMinionXP);

    if ((libSprt_gv_dEBUGBonusMinionXP == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_4FF23A72"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_36D4508C"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleMinionBonusXPOnOff_Init () {

    libSprt_gt_DEBUGToggleMinionBonusXPOnOff = TriggerCreate("libSprt_gt_DEBUGToggleMinionBonusXPOnOff_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleMinionBonusXPOnOff, c_playerAny, "togbonusminionxp", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Tower System On/Off (togtowersystem)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libAIAI_gv_towerSystemOn == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_AF77925B"), true);

        libAIAI_gf_TowerTurnTowerSystemOnOff(false);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_2D16A0B3"), true);

        libAIAI_gf_TowerTurnTowerSystemOnOff(true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem_Init () {

    libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem = TriggerCreate("libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem, c_playerAny, "togtowersystem", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Tower System On (towerson)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTowerSystemOntowerson_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libAIAI_gv_towerSystemOn = true;

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_A62F09F2"), true);

    libAIAI_gf_TowerTurnTowerSystemOnOff(true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTowerSystemOntowerson_Init () {

    libSprt_gt_DEBUGTowerSystemOntowerson = TriggerCreate("libSprt_gt_DEBUGTowerSystemOntowerson_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTowerSystemOntowerson, c_playerAny, "towerson", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Tower System Off (towersoff)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTowerSystemOfftowersoff_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libAIAI_gv_towerSystemOn = false;

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_608A3134"), true);

    libAIAI_gf_TowerTurnTowerSystemOnOff(false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTowerSystemOfftowersoff_Init () {

    libSprt_gt_DEBUGTowerSystemOfftowersoff = TriggerCreate("libSprt_gt_DEBUGTowerSystemOfftowersoff_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTowerSystemOfftowersoff, c_playerAny, "towersoff", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle XP Trickle (togtrickle)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleXPTrickletogtrickle_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_xPTrickleEnabled = !(libGame_gv_xPTrickleEnabled);

    if ((libGame_gv_xPTrickleEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_461B26D2"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_9420B7C3"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleXPTrickletogtrickle_Init () {

    libSprt_gt_DEBUGToggleXPTrickletogtrickle = TriggerCreate("libSprt_gt_DEBUGToggleXPTrickletogtrickle_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleXPTrickletogtrickle, c_playerAny, "togtrickle", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Scale catchup XP Bonus (catchupxpbonus)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_scalingTicks;

    int lv_i;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_data_XP_CatchUpXPBonusScaler = StringToFixed(StringWord(EventChatMessage(false), 2));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus_Init () {

    libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus = TriggerCreate("libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus, c_playerAny, "catchupxpbonus", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Scale catchup XP Penalty (catchupxppenalty)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_scalingTicks;

    int lv_i;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_data_XP_CatchUpXPPunishmentScaler = StringToFixed(StringWord(EventChatMessage(false), 2));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty_Init () {

    libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty = TriggerCreate("libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty, c_playerAny, "catchupxppenalty", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Solo XP (togsoloxp)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleSoloXPtogsoloxp_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_dEBUGSoloXPOn = !(libCore_gv_dEBUGSoloXPOn);

    if ((libCore_gv_dEBUGSoloXPOn == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_FF85EFDF"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DB77E01D"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleSoloXPtogsoloxp_Init () {

    libSprt_gt_DEBUGToggleSoloXPtogsoloxp = TriggerCreate("libSprt_gt_DEBUGToggleSoloXPtogsoloxp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleSoloXPtogsoloxp, c_playerAny, "togsoloxp", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Scale Camps (campscale)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGScaleCampscampscale_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_scalingTicks;

    int lv_i;



    // Automatic Variable Declarations

    int auto9C650F90_ae;

    const int auto9C650F90_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_scalingTicks = StringToInt(StringWord(EventChatMessage(false), 2));

    auto9C650F90_ae = lv_scalingTicks;

    lv_i = 1;

    for ( ; ( (auto9C650F90_ai >= 0 && lv_i <= auto9C650F90_ae) || (auto9C650F90_ai < 0 && lv_i >= auto9C650F90_ae) ) ; lv_i += auto9C650F90_ai ) {

        TriggerExecute(libGame_gt_JungleScalingTimerExpires, true, true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGScaleCampscampscale_Init () {

    libSprt_gt_DEBUGScaleCampscampscale = TriggerCreate("libSprt_gt_DEBUGScaleCampscampscale_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGScaleCampscampscale, c_playerAny, "campscale", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Have AI Take Over (-AI)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHaveAITakeOverAI_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_heroUnit == null)) {

        return true;

    }



    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(EventPlayer()) == false)) {

        libAIAI_gf_HeroAITakeOverHeroForPlayer(EventPlayer());

    }

    else {

        libAIAI_gf_HeroAIReleaseHeroControl(EventPlayer());

    }

    if ((UnitHasBehavior2(libGame_gv_players[EventPlayer()].lv_heroUnit, "HanzoStormBowTargeting") == true)) {

        UnitBehaviorRemove(libGame_gv_players[EventPlayer()].lv_heroUnit, "HanzoStormBowTargeting", 1);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHaveAITakeOverAI_Init () {

    libSprt_gt_DEBUGHaveAITakeOverAI = TriggerCreate("libSprt_gt_DEBUGHaveAITakeOverAI_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAI, c_playerAny, "-AI", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Have AI Take Over (-AI) All

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHaveAITakeOverAIAll_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerHero;



    // Automatic Variable Declarations

    const int autoD2D44B3E_ae = libCore_gv_bALMaxPlayers;

    const int autoD2D44B3E_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_heroUnit == null)) {

        return true;

    }



    lv_playerHero = 1;

    for ( ; ( (autoD2D44B3E_ai >= 0 && lv_playerHero <= autoD2D44B3E_ae) || (autoD2D44B3E_ai < 0 && lv_playerHero >= autoD2D44B3E_ae) ) ; lv_playerHero += autoD2D44B3E_ai ) {

        if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_playerHero) == false)) {

            libAIAI_gf_HeroAITakeOverHeroForPlayer(lv_playerHero);

        }

        else {

            libAIAI_gf_HeroAIReleaseHeroControl(lv_playerHero);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHaveAITakeOverAIAll_Init () {

    libSprt_gt_DEBUGHaveAITakeOverAIAll = TriggerCreate("libSprt_gt_DEBUGHaveAITakeOverAIAll_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAll, c_playerAny, "-AI All", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAll, c_playerAny, "-AIAll", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Have AI Take Over (-AI) AllOff

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHaveAITakeOverAIAllOff_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerHero;



    // Automatic Variable Declarations

    const int auto363A0050_ae = libCore_gv_bALMaxPlayers;

    const int auto363A0050_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_heroUnit == null)) {

        return true;

    }



    lv_playerHero = 1;

    for ( ; ( (auto363A0050_ai >= 0 && lv_playerHero <= auto363A0050_ae) || (auto363A0050_ai < 0 && lv_playerHero >= auto363A0050_ae) ) ; lv_playerHero += auto363A0050_ai ) {

        if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_playerHero) == true)) {

            libAIAI_gf_HeroAIReleaseHeroControl(lv_playerHero);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHaveAITakeOverAIAllOff_Init () {

    libSprt_gt_DEBUGHaveAITakeOverAIAllOff = TriggerCreate("libSprt_gt_DEBUGHaveAITakeOverAIAllOff_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAllOff, c_playerAny, "-AI AllOff", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAllOff, c_playerAny, "-AIAllOff", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Have AI Take Over (-AI) AllOn

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHaveAITakeOverAIAllOn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerHero;



    // Automatic Variable Declarations

    const int autoA73F8635_ae = libCore_gv_bALMaxPlayers;

    const int autoA73F8635_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_heroUnit == null)) {

        return true;

    }



    lv_playerHero = 1;

    for ( ; ( (autoA73F8635_ai >= 0 && lv_playerHero <= autoA73F8635_ae) || (autoA73F8635_ai < 0 && lv_playerHero >= autoA73F8635_ae) ) ; lv_playerHero += autoA73F8635_ai ) {

        if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_playerHero) == false)) {

            libAIAI_gf_HeroAITakeOverHeroForPlayer(lv_playerHero);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHaveAITakeOverAIAllOn_Init () {

    libSprt_gt_DEBUGHaveAITakeOverAIAllOn = TriggerCreate("libSprt_gt_DEBUGHaveAITakeOverAIAllOn_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAllOn, c_playerAny, "-AI AllOn", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHaveAITakeOverAIAllOn, c_playerAny, "-AIAllOn", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - AI Show Talent Build (aishowtalentbuild)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;

    int lv_tier;



    // Automatic Variable Declarations

    const int auto3D49B51C_ae = libCore_gv_talents_MaxTiers_C;

    const int auto3D49B51C_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) == "")) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_3C953080") + IntToText(lv_player)), true);

        return true;

    }



    lv_player = StringToInt(StringWord(EventChatMessage(false), 2));

    if (((lv_player <= 0) || (lv_player > libCore_gv_bALMaxPlayers))) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_27CD8ED6") + IntToText(lv_player)), true);

        return true;

    }



    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_player) == false)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_F2F675AF") + IntToText(lv_player)), true);

        return true;

    }



    if ((libAIAI_gv_aIHeroes[lv_player].lv_pickedTalentBuild == 0)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_AB15DA4B") + IntToText(lv_player)), true);

        return true;

    }



    lv_tier = 1;

    for ( ; ( (auto3D49B51C_ai >= 0 && lv_tier <= auto3D49B51C_ae) || (auto3D49B51C_ai < 0 && lv_tier >= auto3D49B51C_ae) ) ; lv_tier += auto3D49B51C_ai ) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Sprt_31F7C2F4") + IntToText(lv_tier) + StringExternal("Param/Value/lib_Sprt_C9E32AA3") + StringToText((libAIAI_gv_aIHeroes[lv_player].lv_talentBuilds[libAIAI_gv_aIHeroes[lv_player].lv_pickedTalentBuild].lv_talents[lv_tier]))), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild_Init () {

    libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild = TriggerCreate("libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild, c_playerAny, "aishowtalentbuild", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - AI Cycle Through All Heroes (ailoadeveryhero)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_heroIndex;



    // Automatic Variable Declarations

    int autoF6CB69FC_ae;

    const int autoF6CB69FC_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_heroUnit == null)) {

        return true;

    }



    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(EventPlayer()) == false)) {

        libAIAI_gf_HeroAITakeOverHeroForPlayer(EventPlayer());

    }



    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_9988D852"), true);

    autoF6CB69FC_ae = libCore_gv_dataHeroesNumberOfHeroes;

    lv_heroIndex = 1;

    for ( ; ( (autoF6CB69FC_ai >= 0 && lv_heroIndex <= autoF6CB69FC_ae) || (autoF6CB69FC_ai < 0 && lv_heroIndex >= autoF6CB69FC_ae) ) ; lv_heroIndex += autoF6CB69FC_ai ) {

        if ((libGame_gv_players[lv_heroIndex].lv_heroData.lv_unitType != null)) {

            TextExpressionSetToken("Param/Expression/lib_Sprt_871A6EF2", "A", UnitTypeGetName(libGame_gv_players[lv_heroIndex].lv_heroData.lv_unitType));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_871A6EF2"), true);

            libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(lv_heroIndex, 1, 1, 0.0, 1, 0);

            Wait(4.0, c_timeGame);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero_Init () {

    libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero = TriggerCreate("libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero, c_playerAny, "-AILoadEveryHero", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Display Hero AI Debug Info (aidebug)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIndex;



    // Automatic Variable Declarations

    const int auto20E84679_ae = libCore_gv_bALMaxPlayers;

    const int auto20E84679_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libAIAI_gv_heroAIDisplayAIStatus = !(libAIAI_gv_heroAIDisplayAIStatus);

    if ((libAIAI_gv_heroAIDisplayAIStatus == true)) {

        lv_playerIndex = 1;

        for ( ; ( (auto20E84679_ai >= 0 && lv_playerIndex <= auto20E84679_ae) || (auto20E84679_ai < 0 && lv_playerIndex >= auto20E84679_ae) ) ; lv_playerIndex += auto20E84679_ai ) {

            libAIAI_gf_HeroAIUpdateAIStatus(lv_playerIndex);

        }

        if ((TriggerActiveCount(libAIAI_gt_HeroAIUpdateDebugDisplay) == 0)) {

            TriggerExecute(libAIAI_gt_HeroAIUpdateDebugDisplay, true, false);

        }



    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug_Init () {

    libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug = TriggerCreate("libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug, c_playerAny, "aidebug", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Display Defender AI Debug Info (defenderdebug)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libAIAI_gv_defenderAIDisplayAIStatus = !(libAIAI_gv_defenderAIDisplayAIStatus);

    libAIAI_gf_DefenderAIToggleAIStatus(libAIAI_gv_defenderAIDisplayAIStatus);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug_Init () {

    libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug = TriggerCreate("libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug, c_playerAny, "defenderdebug", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Victory (debug-victory)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGVictorydebugvictory_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_faction == libGame_ge_Faction_Order)) {

        UnitKill(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core);

    }

    else {

        UnitKill(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGVictorydebugvictory_Init () {

    libSprt_gt_DEBUGVictorydebugvictory = TriggerCreate("libSprt_gt_DEBUGVictorydebugvictory_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGVictorydebugvictory, c_playerAny, "debug-victory", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Structures 1 Shot Minions (killer-structures)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStructures1ShotMinionskillerstructures_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_minionFactor;

    string lv_mercFactor;

    int lv_playerIndex;



    // Automatic Variable Declarations

    playergroup autoEFF6EF53_g;

    int autoEFF6EF53_var;



    // Variable Initialization

    lv_minionFactor = "8";

    lv_mercFactor = "-6.20";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_926A367D"), true);

    autoEFF6EF53_g = libCore_gv_nPCPlayers;

    autoEFF6EF53_var = -1;

    while (true) {

        	autoEFF6EF53_var = PlayerGroupNextPlayer(autoEFF6EF53_g, autoEFF6EF53_var);

        	if (autoEFF6EF53_var<0) { break; }

        	CatalogFieldValueSet(c_gameCatalogEffect, "CannonTowerL2Damage", "AttributeFactor[" + IntToString(2) + "]", autoEFF6EF53_var, lv_minionFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "CannonTowerL2Damage", "AttributeFactor[" + IntToString(4) + "]", autoEFF6EF53_var, lv_mercFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "CannonTowerL3Damage", "AttributeFactor[" + IntToString(2) + "]", autoEFF6EF53_var, lv_minionFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "CannonTowerL3Damage", "AttributeFactor[" + IntToString(4) + "]", autoEFF6EF53_var, lv_mercFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "TownHallL2WeaponDamage", "AttributeFactor[" + IntToString(2) + "]", autoEFF6EF53_var, lv_minionFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "TownHallL2WeaponDamage", "AttributeFactor[" + IntToString(4) + "]", autoEFF6EF53_var, lv_mercFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "TownHallL3WeaponDamage", "AttributeFactor[" + IntToString(2) + "]", autoEFF6EF53_var, lv_minionFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "TownHallL3WeaponDamage", "AttributeFactor[" + IntToString(4) + "]", autoEFF6EF53_var, lv_mercFactor);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStructures1ShotMinionskillerstructures_Init () {

    libSprt_gt_DEBUGStructures1ShotMinionskillerstructures = TriggerCreate("libSprt_gt_DEBUGStructures1ShotMinionskillerstructures_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStructures1ShotMinionskillerstructures, c_playerAny, "killer-structures", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Increased Minion Damage (killer-minions)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGIncreasedMinionDamagekillerminions_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_structureFactor;

    int lv_playerIndex;



    // Automatic Variable Declarations

    playergroup auto29413633_g;

    int auto29413633_var;



    // Variable Initialization

    lv_structureFactor = "3.5";



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_8C4049FA"), true);

    auto29413633_g = libCore_gv_nPCPlayers;

    auto29413633_var = -1;

    while (true) {

        	auto29413633_var = PlayerGroupNextPlayer(auto29413633_g, auto29413633_var);

        	if (auto29413633_var<0) { break; }

        	CatalogFieldValueSet(c_gameCatalogEffect, "FootmanMinionWeaponDamage", "AttributeFactor[" + IntToString(2) + "]", auto29413633_var, "-.5625");

        CatalogFieldValueSet(c_gameCatalogEffect, "FootmanMinionWeaponDamage", "AttributeFactor[" + IntToString(4) + "]", auto29413633_var, "-.15");

        CatalogFieldValueSet(c_gameCatalogEffect, "FootmanMinionWeaponDamage", "AttributeFactor[" + IntToString(7) + "]", auto29413633_var, lv_structureFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "WizardMinionWeaponDamage", "AttributeFactor[" + IntToString(2) + "]", auto29413633_var, "2.50");

        CatalogFieldValueSet(c_gameCatalogEffect, "WizardMinionWeaponDamage", "AttributeFactor[" + IntToString(4) + "]", auto29413633_var, "-1.25");

        CatalogFieldValueSet(c_gameCatalogEffect, "WizardMinionWeaponDamage", "AttributeFactor[" + IntToString(7) + "]", auto29413633_var, lv_structureFactor);

        CatalogFieldValueSet(c_gameCatalogEffect, "RangedMinionWeaponDamage", "AttributeFactor[" + IntToString(2) + "]", auto29413633_var, "2.15");

        CatalogFieldValueSet(c_gameCatalogEffect, "RangedMinionWeaponDamage", "AttributeFactor[" + IntToString(4) + "]", auto29413633_var, "-1.20");

        CatalogFieldValueSet(c_gameCatalogEffect, "RangedMinionWeaponDamage", "AttributeFactor[" + IntToString(7) + "]", auto29413633_var, lv_structureFactor);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGIncreasedMinionDamagekillerminions_Init () {

    libSprt_gt_DEBUGIncreasedMinionDamagekillerminions = TriggerCreate("libSprt_gt_DEBUGIncreasedMinionDamagekillerminions_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGIncreasedMinionDamagekillerminions, c_playerAny, "killer-minions", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Refresh Cooldowns (-cdr)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGRefreshCooldownscdr_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gf_HeroRefreshCooldowns(EventPlayer(), false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGRefreshCooldownscdr_Init () {

    libSprt_gt_DEBUGRefreshCooldownscdr = TriggerCreate("libSprt_gt_DEBUGRefreshCooldownscdr_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGRefreshCooldownscdr, c_playerAny, "-cdr", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGRefreshCooldownscdr, c_playerAny, "cdr", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Defeat (debug-defeat)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDefeatdebugdefeat_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_players[EventPlayer()].lv_faction == libGame_ge_Faction_Order)) {

        UnitKill(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core);

    }

    else {

        UnitKill(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDefeatdebugdefeat_Init () {

    libSprt_gt_DEBUGDefeatdebugdefeat = TriggerCreate("libSprt_gt_DEBUGDefeatdebugdefeat_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGDefeatdebugdefeat, c_playerAny, "debug-defeat", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Upvote (debug-upvote)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGUpvotedebugupvote_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libUIUI_gt_UIEndofMatchAwardsUpVoteButtonClicked, false, false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGUpvotedebugupvote_Init () {

    libSprt_gt_DEBUGUpvotedebugupvote = TriggerCreate("libSprt_gt_DEBUGUpvotedebugupvote_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGUpvotedebugupvote, c_playerAny, "debug-upvote", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Tie (debug-tie)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTiedebugtie_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitKill(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core);

    UnitKill(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTiedebugtie_Init () {

    libSprt_gt_DEBUGTiedebugtie = TriggerCreate("libSprt_gt_DEBUGTiedebugtie_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTiedebugtie, c_playerAny, "debug-tie", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Hero AI (togheroai)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleHeroAItogheroai_Func (bool testConds, bool runActions) {

    // Variable Declarations

    bool lv_heroAICurrentlyActive;

    int lv_playerIndex;



    // Automatic Variable Declarations

    int auto17C4EA2D_ae;

    int autoECA3F8F5_ae;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto17C4EA2D_ae = libCore_gv_bALMaxPlayers;

    lv_playerIndex = 1;

    for ( ; lv_playerIndex <= auto17C4EA2D_ae ; lv_playerIndex += 1 ) {

        if ((libAIAI_gf_HeroAIIsPlayerActive(lv_playerIndex, 2) == true) && (libAIAI_gv_aIHeroes[lv_playerIndex].lv_aIEnabled == true)) {

            lv_heroAICurrentlyActive = true;

        }



    }

    autoECA3F8F5_ae = 10;

    lv_playerIndex = 1;

    for ( ; lv_playerIndex <= autoECA3F8F5_ae ; lv_playerIndex += 1 ) {

        if ((libAIAI_gf_HeroAIIsPlayerActive(lv_playerIndex, 2) == true)) {

            if ((lv_heroAICurrentlyActive == true)) {

                if ((libAIAI_gv_aIHeroes[lv_playerIndex].lv_aIEnabled == true)) {

                    libAIAI_gf_HeroAIDisableAIForPlayer(lv_playerIndex);

                }



            }

            else {

                if ((libAIAI_gv_aIHeroes[lv_playerIndex].lv_aIEnabled == false)) {

                    libAIAI_gf_HeroAIEnableAIForPlayer(lv_playerIndex);

                }



            }

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleHeroAItogheroai_Init () {

    libSprt_gt_DEBUGToggleHeroAItogheroai = TriggerCreate("libSprt_gt_DEBUGToggleHeroAItogheroai_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleHeroAItogheroai, c_playerAny, "togheroai", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stop AI Think Tree

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStopAIThinkTree_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;



    // Automatic Variable Declarations

    unitgroup autoDEA8DC14_g;

    int autoDEA8DC14_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    autoDEA8DC14_g = UnitGroupSelected(EventPlayer());

    autoDEA8DC14_u = UnitGroupCount(autoDEA8DC14_g, c_unitCountAll);

    for (;; autoDEA8DC14_u -= 1) {

        lv_itUnit = UnitGroupUnitFromEnd(autoDEA8DC14_g, autoDEA8DC14_u);

        if (lv_itUnit == null) { break; }

        UnitDestroyAIThinkTree(lv_itUnit);

        UnitIssueOrder(lv_itUnit, Order(libAIAI_gv_aIStopAbil), c_orderQueueReplace);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStopAIThinkTree_Init () {

    libSprt_gt_DEBUGStopAIThinkTree = TriggerCreate("libSprt_gt_DEBUGStopAIThinkTree_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStopAIThinkTree, c_playerAny, "stopthinktree", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Start AI Think Tree

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStartAIThinkTree_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;



    // Automatic Variable Declarations

    unitgroup auto0BB8D593_g;

    int auto0BB8D593_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto0BB8D593_g = UnitGroupSelected(EventPlayer());

    auto0BB8D593_u = UnitGroupCount(auto0BB8D593_g, c_unitCountAll);

    for (;; auto0BB8D593_u -= 1) {

        lv_itUnit = UnitGroupUnitFromEnd(auto0BB8D593_g, auto0BB8D593_u);

        if (lv_itUnit == null) { break; }

        UnitCreateAIThinkTree(lv_itUnit);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStartAIThinkTree_Init () {

    libSprt_gt_DEBUGStartAIThinkTree = TriggerCreate("libSprt_gt_DEBUGStartAIThinkTree_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStartAIThinkTree, c_playerAny, "startthinktree", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stop Regen (stopregen)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStopRegenstopregen_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;



    // Automatic Variable Declarations

    unitgroup auto89F280D3_g;

    int auto89F280D3_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto89F280D3_g = UnitGroupSelected(EventPlayer());

    auto89F280D3_u = UnitGroupCount(auto89F280D3_g, c_unitCountAll);

    for (;; auto89F280D3_u -= 1) {

        lv_itUnit = UnitGroupUnitFromEnd(auto89F280D3_g, auto89F280D3_u);

        if (lv_itUnit == null) { break; }

        UnitSetPropertyFixed(lv_itUnit, c_unitPropLifeRegen, 0.0);

        UnitSetPropertyFixed(lv_itUnit, c_unitPropEnergyRegen, 0.0);

        UnitSetPropertyFixed(lv_itUnit, c_unitPropShieldsRegen, 0.0);

    }

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E07BE344"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStopRegenstopregen_Init () {

    libSprt_gt_DEBUGStopRegenstopregen = TriggerCreate("libSprt_gt_DEBUGStopRegenstopregen_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStopRegenstopregen, c_playerAny, "stopregen", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Stop Health Regen For All Players (noregen)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itTeam;

    int lv_itPlayer;

    unit lv_itUnit;



    // Automatic Variable Declarations

    const int auto6EDBB11F_ae = 2;

    const int auto6EDBB11F_ai = 1;

    playergroup auto6F158E2D_g;

    unitgroup auto6FB9DA5E_g;

    int auto6FB9DA5E_u;

    const int auto322481F7_ae = 2;

    const int auto322481F7_ai = 1;

    playergroup auto0209C5C4_g;

    unitgroup auto45D8AE74_g;

    int auto45D8AE74_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_dEBUGNoRegen == false)) {

        lv_itTeam = 1;

        for ( ; ( (auto322481F7_ai >= 0 && lv_itTeam <= auto322481F7_ae) || (auto322481F7_ai < 0 && lv_itTeam >= auto322481F7_ae) ) ; lv_itTeam += auto322481F7_ai ) {

            auto0209C5C4_g = libGame_gf_PlayersOnTeamHeroes(lv_itTeam, false);

            lv_itPlayer = -1;

            while (true) {

                	lv_itPlayer = PlayerGroupNextPlayer(auto0209C5C4_g, lv_itPlayer);

                	if (lv_itPlayer<0) { break; }

                	UnitBehaviorAdd(libGame_gv_players[lv_itPlayer].lv_heroUnit, "DEBUGSuppressLifeRegeneration", libGame_gv_players[lv_itPlayer].lv_heroUnit, 1);

                auto45D8AE74_g = libGame_gv_players[lv_itPlayer].lv_heroUnitGroup;

                auto45D8AE74_u = UnitGroupCount(auto45D8AE74_g, c_unitCountAll);

                for (;; auto45D8AE74_u -= 1) {

                    lv_itUnit = UnitGroupUnitFromEnd(auto45D8AE74_g, auto45D8AE74_u);

                    if (lv_itUnit == null) { break; }

                    UnitBehaviorAdd(lv_itUnit, "DEBUGSuppressLifeRegeneration", lv_itUnit, 1);

                }

            }

        }

        libSprt_gv_dEBUGNoRegen = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_95A37801"), true);

    }

    else {

        lv_itTeam = 1;

        for ( ; ( (auto6EDBB11F_ai >= 0 && lv_itTeam <= auto6EDBB11F_ae) || (auto6EDBB11F_ai < 0 && lv_itTeam >= auto6EDBB11F_ae) ) ; lv_itTeam += auto6EDBB11F_ai ) {

            auto6F158E2D_g = libGame_gf_PlayersOnTeamHeroes(lv_itTeam, false);

            lv_itPlayer = -1;

            while (true) {

                	lv_itPlayer = PlayerGroupNextPlayer(auto6F158E2D_g, lv_itPlayer);

                	if (lv_itPlayer<0) { break; }

                	UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_heroUnit, "DEBUGSuppressLifeRegeneration", 1);

                auto6FB9DA5E_g = libGame_gv_players[lv_itPlayer].lv_heroUnitGroup;

                auto6FB9DA5E_u = UnitGroupCount(auto6FB9DA5E_g, c_unitCountAll);

                for (;; auto6FB9DA5E_u -= 1) {

                    lv_itUnit = UnitGroupUnitFromEnd(auto6FB9DA5E_g, auto6FB9DA5E_u);

                    if (lv_itUnit == null) { break; }

                    UnitBehaviorRemove(lv_itUnit, "DEBUGSuppressLifeRegeneration", 1);

                }

            }

        }

        libSprt_gv_dEBUGNoRegen = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_86123032"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen_Init () {

    libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen = TriggerCreate("libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen, c_playerAny, "noregen", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Core Shield Mechanic (togcoreshield)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup autoA1E469BD_g;

    int autoA1E469BD_u;

    unit autoA1E469BD_var;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    autoA1E469BD_g = UnitGroup("KingsCore", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    autoA1E469BD_u = UnitGroupCount(autoA1E469BD_g, c_unitCountAll);

    for (;; autoA1E469BD_u -= 1) {

        autoA1E469BD_var = UnitGroupUnitFromEnd(autoA1E469BD_g, autoA1E469BD_u);

        if (autoA1E469BD_var == null) { break; }

        if ((UnitHasBehavior2(autoA1E469BD_var, "CoreScaling") == true)) {

            TextExpressionSetToken("Param/Expression/lib_Sprt_A2A9322D", "A", IntToText(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(autoA1E469BD_var))));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_A2A9322D"), true);

            UnitBehaviorAdd(autoA1E469BD_var, "CoreShieldsLevel1", autoA1E469BD_var, 1);

            UnitBehaviorAdd(autoA1E469BD_var, "CoreShieldsLevel2", autoA1E469BD_var, 1);

            UnitBehaviorAdd(autoA1E469BD_var, "CoreShieldsLevel3", autoA1E469BD_var, 1);

            UnitBehaviorRemove(autoA1E469BD_var, "CoreScaling", 1);

        }

        else {

            TextExpressionSetToken("Param/Expression/lib_Sprt_F5CC744D", "A", IntToText(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(autoA1E469BD_var))));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_F5CC744D"), true);

            UnitBehaviorRemove(autoA1E469BD_var, "CoreShieldsLevel1", 1);

            UnitBehaviorRemove(autoA1E469BD_var, "CoreShieldsLevel2", 1);

            UnitBehaviorRemove(autoA1E469BD_var, "CoreShieldsLevel3", 1);

            UnitBehaviorAdd(autoA1E469BD_var, "CoreScaling", autoA1E469BD_var, 1);

        }

        libGame_gf_CoreUpdateScaling();

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield_Init () {

    libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield = TriggerCreate("libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield, c_playerAny, "togcoreshield", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Debug Output (togdebug)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleDebugOutputtogdebug_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGDebugMessagesEnabled = !(libSprt_gv_dEBUGDebugMessagesEnabled);

    if ((libSprt_gv_dEBUGDebugMessagesEnabled == true)) {

        TriggerDebugOutputEnable(true);

    }

    else {

        TriggerDebugOutputEnable(false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleDebugOutputtogdebug_Init () {

    libSprt_gt_DEBUGToggleDebugOutputtogdebug = TriggerCreate("libSprt_gt_DEBUGToggleDebugOutputtogdebug_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleDebugOutputtogdebug, c_playerAny, "togdebug", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle For Cinematics (togcine)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleForCinematicstogcine_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unitgroup lv_allLivingUnits;



    // Automatic Variable Declarations

    unitgroup auto7F33C28F_g;

    int auto7F33C28F_u;

    unit auto7F33C28F_var;

    unitgroup auto32A801C9_g;

    int auto32A801C9_u;

    unit auto32A801C9_var;



    // Variable Initialization

    lv_allLivingUnits = UnitGroupEmpty();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_allLivingUnits = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    libSprt_gv_dEBUGCinematicsModeEnabled = !(libSprt_gv_dEBUGCinematicsModeEnabled);

    if ((libSprt_gv_dEBUGCinematicsModeEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_BD3F04C7"), true);

        auto32A801C9_g = lv_allLivingUnits;

        auto32A801C9_u = UnitGroupCount(auto32A801C9_g, c_unitCountAll);

        for (;; auto32A801C9_u -= 1) {

            auto32A801C9_var = UnitGroupUnitFromEnd(auto32A801C9_g, auto32A801C9_u);

            if (auto32A801C9_var == null) { break; }

            UnitBehaviorAdd(auto32A801C9_var, "CinematicsBehavior", auto32A801C9_var, 1);

        }

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_FF85FFD0"), true);

        auto7F33C28F_g = lv_allLivingUnits;

        auto7F33C28F_u = UnitGroupCount(auto7F33C28F_g, c_unitCountAll);

        for (;; auto7F33C28F_u -= 1) {

            auto7F33C28F_var = UnitGroupUnitFromEnd(auto7F33C28F_g, auto7F33C28F_u);

            if (auto7F33C28F_var == null) { break; }

            UnitBehaviorRemove(auto7F33C28F_var, "CinematicsBehavior", 1);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleForCinematicstogcine_Init () {

    libSprt_gt_DEBUGToggleForCinematicstogcine = TriggerCreate("libSprt_gt_DEBUGToggleForCinematicstogcine_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleForCinematicstogcine, c_playerAny, "togcine", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle For Map Text (togmaptext)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleForMapTexttogmaptext_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itCamp;



    // Automatic Variable Declarations

    int autoBD862901_ae;

    const int autoBD862901_ai = 1;

    int auto164B4004_ae;

    const int auto164B4004_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGMapTextEnabled = !(libSprt_gv_dEBUGMapTextEnabled);

    if ((libSprt_gv_dEBUGMapTextEnabled == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_A74648E9"), true);

        auto164B4004_ae = libMapM_gv_jungleNumberOfCreepCamps;

        lv_itCamp = 1;

        for ( ; ( (auto164B4004_ai >= 0 && lv_itCamp <= auto164B4004_ae) || (auto164B4004_ai < 0 && lv_itCamp >= auto164B4004_ae) ) ; lv_itCamp += auto164B4004_ai ) {

            libMapM_gf_JungleUpdateTextTagForCamp(lv_itCamp);

        }

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_B11A350A"), true);

        autoBD862901_ae = libMapM_gv_jungleNumberOfCreepCamps;

        lv_itCamp = 1;

        for ( ; ( (autoBD862901_ai >= 0 && lv_itCamp <= autoBD862901_ae) || (autoBD862901_ai < 0 && lv_itCamp >= autoBD862901_ae) ) ; lv_itCamp += autoBD862901_ai ) {

            libMapM_gf_JungleUpdateTextTagForCamp(lv_itCamp);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleForMapTexttogmaptext_Init () {

    libSprt_gt_DEBUGToggleForMapTexttogmaptext = TriggerCreate("libSprt_gt_DEBUGToggleForMapTexttogmaptext_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleForMapTexttogmaptext, c_playerAny, "togmaptext", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Turn Off Weather

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTurnOffWeather_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libNtve_gf_ShowHideDoodadsInRegion(false, RegionEntireMap(), "Storm_Doodad_KingsCrest_Docks_RollingFog");

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTurnOffWeather_Init () {

    libSprt_gt_DEBUGTurnOffWeather = TriggerCreate("libSprt_gt_DEBUGTurnOffWeather_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTurnOffWeather, c_playerAny, "stopfog", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Turn On Minion Spell Resist

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTurnOnMinionSpellResist_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_minionTakesReducedSpellDamage = true;

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_3F6D5C58"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTurnOnMinionSpellResist_Init () {

    libSprt_gt_DEBUGTurnOnMinionSpellResist = TriggerCreate("libSprt_gt_DEBUGTurnOnMinionSpellResist_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTurnOnMinionSpellResist, c_playerAny, "-reducespelldamage", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTurnOnMinionSpellResist, c_playerAny, "-waveclear", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Complete All Quests

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGCompleteAllQuests_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gf_DEBUGIncrementAllQuests(EventPlayer(), 0);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGCompleteAllQuests_Init () {

    libSprt_gt_DEBUGCompleteAllQuests = TriggerCreate("libSprt_gt_DEBUGCompleteAllQuests_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGCompleteAllQuests, c_playerAny, "questcomplete", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Progress All Quests

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGProgressAllQuests_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_enteredTokenCount;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_enteredTokenCount = StringToFixed(StringWord(EventChatMessage(false), 2));



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((lv_enteredTokenCount == 0.0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_73E1C232"), true);

        return true;

    }



    libSprt_gf_DEBUGIncrementAllQuests(EventPlayer(), FixedToInt(lv_enteredTokenCount));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGProgressAllQuests_Init () {

    libSprt_gt_DEBUGProgressAllQuests = TriggerCreate("libSprt_gt_DEBUGProgressAllQuests_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGProgressAllQuests, c_playerAny, "questprogress", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Team Fight Perf Test

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTeamFightPerfTest_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerIndex;

    int lv_waitTick;

    point lv_center;



    // Automatic Variable Declarations

    const int autoC249F3ED_ae = 10;

    const int autoC249F3ED_ai = 1;

    const int auto1BC2495B_ae = 12;

    const int auto1BC2495B_ai = 1;

    const int auto760EA7FC_ae = 10;

    const int auto760EA7FC_ai = 1;

    const int autoF13D00DA_ae = 10;

    const int autoF13D00DA_ai = 1;



    // Variable Initialization

    lv_center = Point(119.0, 171.0);



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_playerIndex = 1;

    for ( ; ( (autoC249F3ED_ai >= 0 && lv_playerIndex <= autoC249F3ED_ae) || (autoC249F3ED_ai < 0 && lv_playerIndex >= autoC249F3ED_ae) ) ; lv_playerIndex += autoC249F3ED_ai ) {

        if ((libGame_gv_players[lv_playerIndex].lv_heroUnit != null)) {

            UnitSetPropertyFixed(libGame_gv_players[lv_playerIndex].lv_heroUnit, c_unitPropXP, (UnitGetPropertyFixed(libGame_gv_players[lv_playerIndex].lv_heroUnit, c_unitPropXP, c_unitPropCurrent) + 50000.0));

        }



    }

    ConsoleCommand("speed 8", true, true);

    libGame_gf_CameraPanCameraForPlayerAndUpdateMapBoundsIfNecessary(1, lv_center, 0.0, -1, 0.0, false);

    Wait(2.0, c_timeGame);

    ConsoleCommand("chat startgame", true, true);

    ConsoleCommand("chat -ai", true, true);

    ConsoleCommand("sm", true, true);

    lv_waitTick = 1;

    for ( ; ( (auto1BC2495B_ai >= 0 && lv_waitTick <= auto1BC2495B_ae) || (auto1BC2495B_ai < 0 && lv_waitTick >= auto1BC2495B_ae) ) ; lv_waitTick += auto1BC2495B_ai ) {

        lv_playerIndex = 1;

        for ( ; ( (auto760EA7FC_ai >= 0 && lv_playerIndex <= auto760EA7FC_ae) || (auto760EA7FC_ai < 0 && lv_playerIndex >= auto760EA7FC_ae) ) ; lv_playerIndex += auto760EA7FC_ai ) {

            if ((libGame_gv_players[lv_playerIndex].lv_heroUnit != null)) {

                UnitSetPosition(libGame_gv_players[lv_playerIndex].lv_heroUnit, libGame_gv_players[lv_playerIndex].lv_spawnPoint, false);

            }



        }

        Wait(3.0, c_timeGame);

    }

    ConsoleCommand("speed 1", true, true);

    ConsoleCommand("chat creepcamp", true, true);

    Wait(2.0, c_timeGame);

    lv_playerIndex = 1;

    for ( ; ( (autoF13D00DA_ai >= 0 && lv_playerIndex <= autoF13D00DA_ae) || (autoF13D00DA_ai < 0 && lv_playerIndex >= autoF13D00DA_ae) ) ; lv_playerIndex += autoF13D00DA_ai ) {

        if ((libGame_gv_players[lv_playerIndex].lv_heroUnit != null)) {

            UnitSetPosition(libGame_gv_players[lv_playerIndex].lv_heroUnit, RegionRandomPoint(RegionCircle(lv_center, 4.0)), false);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTeamFightPerfTest_Init () {

    libSprt_gt_DEBUGTeamFightPerfTest = TriggerCreate("libSprt_gt_DEBUGTeamFightPerfTest_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTeamFightPerfTest, c_playerAny, "perftest", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle Jungle Camp Debug (togcampdebug)

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((TriggerIsEnabled(libSprt_gt_DEBUGTargetJungleCreepState) == false)) {

        TriggerEnable(libSprt_gt_DEBUGTargetJungleCreepState, true);

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_18DF4B42"), true);

    }

    else {

        TriggerEnable(libSprt_gt_DEBUGTargetJungleCreepState, false);

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_1568A9D4"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug_Init () {

    libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug = TriggerCreate("libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug, c_playerAny, "togcampdebug", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Target Jungle Creep State

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTargetJungleCreepState_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_creepUnit;

    int lv_camp;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_creepUnit = UnitGroupUnit(UnitGroupSelected(1), 1);

    lv_camp = libMapM_gf_JungleGetJungleCampForUnit(lv_creepUnit);

    if ((lv_camp != 0)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_79246586", "A", IntToText(lv_camp));

        TextExpressionSetToken("Param/Expression/lib_Sprt_79246586", "B", StringToText(libMapM_ge_JungleCampStates_Ident(libMapM_gv_jungleCreepCamps[lv_camp].lv_aIState)));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_79246586"), true);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTargetJungleCreepState_Init () {

    libSprt_gt_DEBUGTargetJungleCreepState = TriggerCreate("libSprt_gt_DEBUGTargetJungleCreepState_Func");

    TriggerEnable(libSprt_gt_DEBUGTargetJungleCreepState, false);

    TriggerAddEventTimePeriodic(libSprt_gt_DEBUGTargetJungleCreepState, 0.0625, c_timeGame);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - 60 Second Pause

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUG60SecondPause_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_dEBUG60SecondPauseOnOff == true)) {

        libSprt_gv_dEBUG60SecondPauseOnOff = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_158D8409"), true);

    }

    else {

        libSprt_gv_dEBUG60SecondPauseOnOff = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_E94315CF"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUG60SecondPause_Init () {

    libSprt_gt_DEBUG60SecondPause = TriggerCreate("libSprt_gt_DEBUG60SecondPause_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUG60SecondPause, c_playerAny, "60on", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Trigger A Save

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTriggerASave_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        return true;

    }



    GameSaveCreate(StringExternal("Param/Value/lib_Sprt_D009FA2B"), StringExternal("Param/Value/lib_Sprt_F0890456"), "", false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTriggerASave_Init () {

    libSprt_gt_DEBUGTriggerASave = TriggerCreate("libSprt_gt_DEBUGTriggerASave_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTriggerASave, c_playerAny, "-savegame", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Hero Is Alive

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGHeroIsAlive_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((UnitIsAlive(libGame_gv_players[EventPlayer()].lv_heroUnit) == true)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_5A22D656", "A", UnitTypeGetName(UnitGetType(libGame_gv_players[EventPlayer()].lv_heroUnit)));

        TextExpressionSetToken("Param/Expression/lib_Sprt_5A22D656", "A", UnitTypeGetName(UnitGetType(libGame_gv_players[EventPlayer()].lv_heroUnit)));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_5A22D656"), true);

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_69E15644", "A", UnitTypeGetName(UnitGetType(libGame_gv_players[EventPlayer()].lv_heroUnit)));

        TextExpressionSetToken("Param/Expression/lib_Sprt_69E15644", "A", UnitTypeGetName(UnitGetType(libGame_gv_players[EventPlayer()].lv_heroUnit)));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_69E15644"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGHeroIsAlive_Init () {

    libSprt_gt_DEBUGHeroIsAlive = TriggerCreate("libSprt_gt_DEBUGHeroIsAlive_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGHeroIsAlive, c_playerAny, "-heroalive", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Short Hero Death

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGShortHeroDeath_Func (bool testConds, bool runActions) {

    // Variable Declarations

    text lv_msg;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }



        if (!((StringCompare(StringWord(EventChatMessage(false), 1), EventChatMessage(true), c_stringNoCase) == 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_sYSDeathTimerCap = StringToFixed(StringWord(EventChatMessage(false), 2));

    if ((libCore_gv_sYSDeathTimerCap <= 0.0)) {

        libCore_gv_sYSDeathTimerCap = 0.0;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_DB6D955D"), true);

    }

    else {

        TextExpressionSetToken("Param/Expression/lib_Sprt_C2D3C357", "A", FixedToText(libCore_gv_sYSDeathTimerCap, 0));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_C2D3C357"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGShortHeroDeath_Init () {

    libSprt_gt_DEBUGShortHeroDeath = TriggerCreate("libSprt_gt_DEBUGShortHeroDeath_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGShortHeroDeath, c_playerAny, "SHORTDEATH", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Invulnerable Structures

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGInvulnerableStructures_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_town;

    int lv_structure;



    // Automatic Variable Declarations

    int auto9A9C00A4_ae;

    const int auto9A9C00A4_ai = 1;

    int auto255D3267_ae;

    const int auto255D3267_ai = 1;

    int autoA30348C2_ae;

    const int autoA30348C2_ai = 1;

    int auto17914A07_ae;

    const int auto17914A07_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_59D31635"), true);

    if ((TimerGetElapsed(libGame_gv_gameTimer) < 30.0)) {

        auto9A9C00A4_ae = libGame_gv_townTownCount;

        lv_town = 1;

        for ( ; ( (auto9A9C00A4_ai >= 0 && lv_town <= auto9A9C00A4_ae) || (auto9A9C00A4_ai < 0 && lv_town >= auto9A9C00A4_ae) ) ; lv_town += auto9A9C00A4_ai ) {

            auto255D3267_ae = libGame_gv_townTownData[lv_town].lv_structureCount;

            lv_structure = 1;

            for ( ; ( (auto255D3267_ai >= 0 && lv_structure <= auto255D3267_ae) || (auto255D3267_ai < 0 && lv_structure >= auto255D3267_ae) ) ; lv_structure += auto255D3267_ai ) {

                UnitBehaviorAdd(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure], "StructureInvulnerability", libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure], 1);

            }

        }

        while (!((TimerGetElapsed(libGame_gv_gameTimer) >= 30.0))) {

            Wait(0.25, c_timeGame);

        }

        autoA30348C2_ae = libGame_gv_townTownCount;

        lv_town = 1;

        for ( ; ( (autoA30348C2_ai >= 0 && lv_town <= autoA30348C2_ae) || (autoA30348C2_ai < 0 && lv_town >= autoA30348C2_ae) ) ; lv_town += autoA30348C2_ai ) {

            auto17914A07_ae = libGame_gv_townTownData[lv_town].lv_structureCount;

            lv_structure = 1;

            for ( ; ( (auto17914A07_ai >= 0 && lv_structure <= auto17914A07_ae) || (auto17914A07_ai < 0 && lv_structure >= auto17914A07_ae) ) ; lv_structure += auto17914A07_ai ) {

                UnitBehaviorRemove(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure], "StructureInvulnerability", 1);

            }

        }

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGInvulnerableStructures_Init () {

    libSprt_gt_DEBUGInvulnerableStructures = TriggerCreate("libSprt_gt_DEBUGInvulnerableStructures_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGInvulnerableStructures, c_playerAny, "invulnerablestructures", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Respawn Structures

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGRespawnStructures_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_townStructureType;

    unit lv_structureUnit;

    string lv_structureUnitType;

    int lv_town;

    int lv_structure;



    // Automatic Variable Declarations

    int auto3DCAC6E1_ae;

    const int auto3DCAC6E1_ai = 1;

    int auto5EA090CD_ae;

    const int auto5EA090CD_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto3DCAC6E1_ae = libGame_gv_townTownCount;

    lv_town = 1;

    for ( ; ( (auto3DCAC6E1_ai >= 0 && lv_town <= auto3DCAC6E1_ae) || (auto3DCAC6E1_ai < 0 && lv_town >= auto3DCAC6E1_ae) ) ; lv_town += auto3DCAC6E1_ai ) {

        auto5EA090CD_ae = libGame_gv_townTownData[lv_town].lv_structureCount;

        lv_structure = 1;

        for ( ; ( (auto5EA090CD_ai >= 0 && lv_structure <= auto5EA090CD_ae) || (auto5EA090CD_ai < 0 && lv_structure >= auto5EA090CD_ae) ) ; lv_structure += auto5EA090CD_ai ) {

            if ((UnitIsAlive(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]) == false)) {

                lv_structureUnitType = libGame_gv_townTownData[lv_town].lv_structureUnitIDs[lv_structure];

                UnitRemove(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]);

                UnitCreate(1, lv_structureUnitType, 0, libGame_gv_townTownData[lv_town].lv_owner, libGame_gv_townTownData[lv_town].lv_structureSpawnPoints[lv_structure], libSprt_gv_rS_Towns[lv_town].lv_structureArray[lv_structure].lv_buildingFacing, null);

                libStEx_gf_MoveUnit(UnitLastCreated(), libSprt_gv_rS_Towns[lv_town].lv_structureArray[lv_structure].lv_buildingPosition, false);

                lv_townStructureType = libGame_gf_TownGetTownStructurePresetFromUnit(lv_structureUnit);

                libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure] = UnitLastCreated();

                ActorSend(libNtve_gf_MainActorofUnit(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]), "Signal PlayBuild");

            }



        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGRespawnStructures_Init () {

    libSprt_gt_DEBUGRespawnStructures = TriggerCreate("libSprt_gt_DEBUGRespawnStructures_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGRespawnStructures, c_playerAny, "-rs", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Kill Structures

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGKillStructures_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_townStructureType;

    unit lv_structureUnit;

    string lv_structureUnitType;

    int lv_town;

    int lv_structure;



    // Automatic Variable Declarations

    int autoB895D9C6_ae;

    const int autoB895D9C6_ai = 1;

    int autoFE778185_ae;

    const int autoFE778185_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    autoB895D9C6_ae = libGame_gv_townTownCount;

    lv_town = 1;

    for ( ; ( (autoB895D9C6_ai >= 0 && lv_town <= autoB895D9C6_ae) || (autoB895D9C6_ai < 0 && lv_town >= autoB895D9C6_ae) ) ; lv_town += autoB895D9C6_ai ) {

        autoFE778185_ae = libGame_gv_townTownData[lv_town].lv_structureCount;

        lv_structure = 1;

        for ( ; ( (autoFE778185_ai >= 0 && lv_structure <= autoFE778185_ae) || (autoFE778185_ai < 0 && lv_structure >= autoFE778185_ae) ) ; lv_structure += autoFE778185_ai ) {

            if ((UnitIsAlive(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]) == true)) {

                UnitKill(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]);

            }



        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGKillStructures_Init () {

    libSprt_gt_DEBUGKillStructures = TriggerCreate("libSprt_gt_DEBUGKillStructures_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGKillStructures, c_playerAny, "-ks", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Collect Structure Data

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGCollectStructureData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_town;

    int lv_structure;



    // Automatic Variable Declarations

    int auto2EED8A50_ae;

    const int auto2EED8A50_ai = 1;

    int auto02FF66E0_ae;

    const int auto02FF66E0_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    Wait(1.0, c_timeGame);

    auto2EED8A50_ae = libGame_gv_townTownCount;

    lv_town = 1;

    for ( ; ( (auto2EED8A50_ai >= 0 && lv_town <= auto2EED8A50_ae) || (auto2EED8A50_ai < 0 && lv_town >= auto2EED8A50_ae) ) ; lv_town += auto2EED8A50_ai ) {

        auto02FF66E0_ae = libGame_gv_townTownData[lv_town].lv_structureCount;

        lv_structure = 1;

        for ( ; ( (auto02FF66E0_ai >= 0 && lv_structure <= auto02FF66E0_ae) || (auto02FF66E0_ai < 0 && lv_structure >= auto02FF66E0_ae) ) ; lv_structure += auto02FF66E0_ai ) {

            libSprt_gv_rS_Towns[lv_town].lv_structureArray[lv_structure].lv_buildingFacing = UnitGetFacing(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]);

            libSprt_gv_rS_Towns[lv_town].lv_structureArray[lv_structure].lv_buildingType = libGame_gv_townTownData[lv_town].lv_structureUnitIDs[lv_structure];

            libSprt_gv_rS_Towns[lv_town].lv_structureArray[lv_structure].lv_buildingPosition = UnitGetPosition(libGame_gv_townTownData[lv_town].lv_structureUnits[lv_structure]);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGCollectStructureData_Init () {

    libSprt_gt_DEBUGCollectStructureData = TriggerCreate("libSprt_gt_DEBUGCollectStructureData_Func");

    TriggerAddEventMapInit(libSprt_gt_DEBUGCollectStructureData);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Game Time

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGGameTime_Func (bool testConds, bool runActions) {

    // Variable Declarations

    text lv_msg;

    const int lv_maxLevel_C = 30;

    int[lv_maxLevel_C + 1] lv_heroLevel;

    fixed lv_newTime;

    fixed lv_newTimeDelta;

    fixed lv_requestedTimeChange;

    fixed lv_newTimerDuration;

    int lv_itTick;

    int lv_heroIndex;

    int lv_skinIndex;

    int lv_mountIndex;

    fixed lv_xP;

    int lv_itPlayer;

    int lv_newLevel;

    unit lv_itHero;

    int lv_itTown;

    unit lv_itStructure;

    region lv_baseRegion;



    // Automatic Variable Declarations

    const int auto51819663_ae = libCore_gv_bALMaxPlayers;

    const int auto51819663_ai = 1;

    int auto1E6EF0E0_ae;

    const int auto1E6EF0E0_ai = 1;

    int autoF862C5F8_ae;

    const int autoF862C5F8_ai = 1;

    const int auto9890D104_ae = libCore_gv_bALMaxPlayers;

    const int auto9890D104_ai = 1;

    unitgroup auto3BB2C50C_g;

    int auto3BB2C50C_u;

    int autoF568AF7C_ae;

    const int autoF568AF7C_ai = 1;

    unitgroup autoA7F07FFE_g;

    int autoA7F07FFE_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }



        if (!((StringCompare(StringWord(EventChatMessage(false), 1), EventChatMessage(true), c_stringNoCase) == 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(TriggerGetCurrent(), false);

    if ((StringCompare(EventChatMessage(false), EventChatMessage(true), c_stringNoCase) == 0)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_3FB0E761", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(TimerGetElapsed(libGame_gv_gameTimer))));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_3FB0E761"));

        TriggerEnable(TriggerGetCurrent(), true);

        return true;

    }



    lv_newTime = StringToFixed(StringWord(EventChatMessage(false), 2));

    if ((lv_newTime <= 0.0)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_822C3F09", "A", StringToText(StringWord(EventChatMessage(false), 2)));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_822C3F09"));

        TriggerEnable(TriggerGetCurrent(), true);

        return true;

    }



    lv_newTimeDelta = ((lv_newTime*60-TimerGetElapsed(libGame_gv_gameTimer))/60);

    if ((lv_newTimeDelta <= libSprt_gv_debug_GameTimeDelta)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_74D22EA0", "A", StringToText(StringWord(EventChatMessage(false), 2)));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_74D22EA0"));

        TriggerEnable(TriggerGetCurrent(), true);

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Sprt_0B245A95", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt((lv_newTime * 60.0))));

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_0B245A95"));

    lv_newLevel = MinI(30, StringToInt(StringWord(EventChatMessage(false), 3)));

    if ((lv_newLevel > 0)) {

        lv_itPlayer = 1;

        for ( ; ( (auto51819663_ai >= 0 && lv_itPlayer <= auto51819663_ae) || (auto51819663_ai < 0 && lv_itPlayer >= auto51819663_ae) ) ; lv_itPlayer += auto51819663_ai ) {

            lv_heroIndex = libGame_gv_players[lv_itPlayer].lv_heroIndex;

            if ((lv_heroIndex == 0)) {

                continue;

            }



            lv_skinIndex = libGame_gv_players[lv_itPlayer].lv_selectedSkin;

            lv_mountIndex = libGame_gv_players[lv_itPlayer].lv_selectedMount;

            lv_xP = libCore_gf_GetTotalXPForLevel(lv_newLevel);

            libUIUI_gf_UIDebugPanelSpawnOrSwapHeroForPlayer(lv_heroIndex, lv_skinIndex, lv_mountIndex, lv_xP, lv_itPlayer, 0);

        }

    }



    if ((lv_newTimeDelta == libSprt_gv_debug_GameTimeDelta)) {

        TriggerEnable(TriggerGetCurrent(), true);

        return true;

    }



    lv_requestedTimeChange = (lv_newTimeDelta-libSprt_gv_debug_GameTimeDelta);

    while (!((TimerIsPaused(libGame_gv_openTheGatesTimer) == false))) {

        Wait(1.0, c_timeGame);

    }

    libNtve_gf_WaitForTimer(libGame_gv_openTheGatesTimer, 0.0, false);

    Wait(1.0, c_timeGame);

    if ((TimerGetRemaining(libGame_gv_jungleWatchTowerStartTimer) > 0.0)) {

        lv_newTimerDuration = MaxF((TimerGetRemaining(libGame_gv_jungleWatchTowerStartTimer)-lv_requestedTimeChange*60), 0.0625);

        TimerStart(libGame_gv_jungleWatchTowerStartTimer, lv_newTimerDuration, false, c_timeGame);

    }



    if ((TimerGetRemaining(libGame_gv_xPTrickleStartTimer) > 0.0)) {

        lv_newTimerDuration = MaxF((TimerGetRemaining(libGame_gv_xPTrickleStartTimer)-lv_requestedTimeChange*60), 0.0625);

        TimerStart(libGame_gv_xPTrickleStartTimer, lv_newTimerDuration, false, c_timeGame);

    }



    Wait(1.0, c_timeGame);

    libGame_gv_scalingTicks = FixedToInt(lv_newTime);

    if ((libGame_gv_scalingTicks > libCore_gv_dataScalingMaxScalingTicks)) {

        libGame_gv_scalingTicks = libCore_gv_dataScalingMaxScalingTicks;

    }



    auto1E6EF0E0_ae = FixedToInt(lv_newTimeDelta);

    lv_itTick = FixedToInt((FixedToInt(libSprt_gv_debug_GameTimeDelta) + 1));

    for ( ; ( (auto1E6EF0E0_ai >= 0 && lv_itTick <= auto1E6EF0E0_ae) || (auto1E6EF0E0_ai < 0 && lv_itTick >= auto1E6EF0E0_ae) ) ; lv_itTick += auto1E6EF0E0_ai ) {

        libGame_gf_JungleUpdateScalingForCamps();

    }

    autoF862C5F8_ae = FixedToInt(lv_newTimeDelta);

    lv_itTick = FixedToInt((FixedToInt(libSprt_gv_debug_GameTimeDelta) + 1));

    for ( ; ( (autoF862C5F8_ai >= 0 && lv_itTick <= autoF862C5F8_ae) || (autoF862C5F8_ai < 0 && lv_itTick >= autoF862C5F8_ae) ) ; lv_itTick += autoF862C5F8_ai ) {

        libGame_gf_CoreUpdateScaling();

    }

    libSprt_gv_debug_GameTimeDelta = lv_newTimeDelta;

    Wait(1.0, c_timeGame);

    lv_itPlayer = 1;

    for ( ; ( (auto9890D104_ai >= 0 && lv_itPlayer <= auto9890D104_ae) || (auto9890D104_ai < 0 && lv_itPlayer >= auto9890D104_ae) ) ; lv_itPlayer += auto9890D104_ai ) {

        lv_heroIndex = libGame_gv_players[lv_itPlayer].lv_heroIndex;

        if ((lv_heroIndex == 0)) {

            continue;

        }



        auto3BB2C50C_g = libGame_gv_players[lv_itPlayer].lv_heroUnitGroup;

        auto3BB2C50C_u = UnitGroupCount(auto3BB2C50C_g, c_unitCountAll);

        for (;; auto3BB2C50C_u -= 1) {

            lv_itHero = UnitGroupUnitFromEnd(auto3BB2C50C_g, auto3BB2C50C_u);

            if (lv_itHero == null) { break; }

            UnitBehaviorRemovePlayer(lv_itHero, "HeroGenericPregameAbilitySuppression", lv_itPlayer, 1);

        }

    }

    if ((lv_newTime >= 15.0)) {

        autoF568AF7C_ae = libGame_gv_townTownCount;

        lv_itTown = 1;

        for ( ; ( (autoF568AF7C_ai >= 0 && lv_itTown <= autoF568AF7C_ae) || (autoF568AF7C_ai < 0 && lv_itTown >= autoF568AF7C_ae) ) ; lv_itTown += autoF568AF7C_ai ) {

            if ((libGame_gv_townTownData[lv_itTown].lv_owner == libCore_gv_cOMPUTER_TeamOrder)) {

                lv_baseRegion = libCore_gv_mAPOrderBaseRegion;

            }

            else {

                lv_baseRegion = libCore_gv_mAPChaosBaseRegion;

            }

            if ((RegionContainsPoint(lv_baseRegion, RegionGetCenter(libGame_gv_townTownData[lv_itTown].lv_townRegion)) == false)) {

                autoA7F07FFE_g = UnitGroup(null, libGame_gv_townTownData[lv_itTown].lv_owner, libGame_gv_townTownData[lv_itTown].lv_townRegion, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

                autoA7F07FFE_u = UnitGroupCount(autoA7F07FFE_g, c_unitCountAll);

                for (;; autoA7F07FFE_u -= 1) {

                    lv_itStructure = UnitGroupUnitFromEnd(autoA7F07FFE_g, autoA7F07FFE_u);

                    if (lv_itStructure == null) { break; }

                    UnitKill(lv_itStructure);

                }

                Wait(0.125, c_timeGame);

            }



        }

    }



    TriggerEnable(TriggerGetCurrent(), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGGameTime_Init () {

    libSprt_gt_DEBUGGameTime = TriggerCreate("libSprt_gt_DEBUGGameTime_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGGameTime, c_playerAny, "GAMETIME", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGGameTime, c_playerAny, "-GT", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Choose Talent

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGChooseTalent_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;

    int lv_tier;

    int lv_button;

    int lv_tierIndex;

    int lv_numPreviousTalents;

    string lv_enteredString;



    // Automatic Variable Declarations

    string autoD4B6119F_val;

    int auto4EB8BA4A_ae;



    // Variable Initialization

    lv_numPreviousTalents = -1;

    lv_enteredString = EventChatMessage(false);



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }



        if (!((StringCompare(StringWord(lv_enteredString, 1), EventChatMessage(true), c_stringNoCase) == 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(lv_enteredString, 1) == "talent")) {

        lv_player = StringToInt(StringWord(lv_enteredString, 2));

        lv_tier = StringToInt(StringWord(lv_enteredString, 3));

        lv_button = StringToInt(StringWord(lv_enteredString, 4));

    }

    else {

        lv_player = UnitGetOwner(UnitGroupUnit(UnitGroupSelected(EventPlayer()), 1));

        lv_tier = libGame_gv_players[lv_player].lv_talent_HeroicTalentTier;

        autoD4B6119F_val = EventChatMessage(false);

        if (autoD4B6119F_val == "ult1") {

            lv_button = 1;

        }

        else if (autoD4B6119F_val == "ult2") {

            lv_button = 2;

        }

        else if (autoD4B6119F_val == "ult3") {

            lv_button = 3;

        }

        else {

        }

    }

    if (((lv_player == 0) || (lv_tier == 0) || (lv_button == 0))) {

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_C75DC32D"));

        return true;

    }



    if (((lv_player < 1) || (lv_player > libCore_gv_bALMaxPlayers))) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_62EA0E6F", "A", IntToText(lv_player));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_62EA0E6F"));

        return true;

    }



    libSprt_gf_DEBUGTalentsRespec(lv_player, lv_tier);

    auto4EB8BA4A_ae = (lv_tier - 1);

    lv_tierIndex = 1;

    for ( ; lv_tierIndex <= auto4EB8BA4A_ae ; lv_tierIndex += 1 ) {

        lv_numPreviousTalents += libGame_gv_talents_TalentChoices[lv_player][lv_tierIndex].lv_numberOfTalentsForThisTier;

    }

    TextExpressionSetToken("Param/Expression/lib_Sprt_B6092116", "C", IntToText(lv_player));

    TextExpressionSetToken("Param/Expression/lib_Sprt_B6092116", "A", IntToText(lv_tier));

    TextExpressionSetToken("Param/Expression/lib_Sprt_B6092116", "B", IntToText(lv_button));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_B6092116"), true);

    libGame_gf_TalentsChooseTalentForPlayer(lv_tier, lv_button, lv_player);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGChooseTalent_Init () {

    libSprt_gt_DEBUGChooseTalent = TriggerCreate("libSprt_gt_DEBUGChooseTalent_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGChooseTalent, c_playerAny, "TALENT", false);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGChooseTalent, c_playerAny, "ult1", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGChooseTalent, c_playerAny, "ult2", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGChooseTalent, c_playerAny, "ult3", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - XPRange

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGXPRange_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;

    fixed lv_inputXPRange;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }



        if (!((StringCompare(StringWord(EventChatMessage(false), 1), EventChatMessage(true), c_stringNoCase) == 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) == null)) {

        TextExpressionSetToken("Param/Expression/lib_Sprt_43BDE6FF", "A", FixedToText(libCore_gv_bALXPRadius, c_fixedPrecisionAny));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_43BDE6FF"));

        return true;

    }

    else {

        libCore_gv_bALXPRadius = StringToFixed(StringWord(EventChatMessage(false), 2));

        TextExpressionSetToken("Param/Expression/lib_Sprt_144B5823", "A", FixedToText(libCore_gv_bALXPRadius, c_fixedPrecisionAny));

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Sprt_144B5823"));

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGXPRange_Init () {

    libSprt_gt_DEBUGXPRange = TriggerCreate("libSprt_gt_DEBUGXPRange_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGXPRange, c_playerAny, "XPRange", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Afk System

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGAfkSystem_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gv_afk_DebugOn == true)) {

        libGame_gv_afk_DebugOn = false;

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_Sprt_78715EA0"));

    }

    else {

        libGame_gv_afk_DebugOn = true;

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_Sprt_F7A53840"));

        if ((libGame_gv_afk_AfkDetectionSystemSkipped == true)) {

            libGame_gf_AfkStartAfkWarningSystem(true);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGAfkSystem_Init () {

    libSprt_gt_DEBUGAfkSystem = TriggerCreate("libSprt_gt_DEBUGAfkSystem_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGAfkSystem, c_playerAny, "DEBUGAFK", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Start DPS Tracker

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGStartDPSTracker_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((TriggerIsEnabled(libSprt_gt_DEBUGDPSTracker) == false) && ((StringSub(EventChatMessage(false), 13, 14) == "") || (StringSub(EventChatMessage(false), 13, 14) == "0"))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F79A7687"), true);

        return true;

    }

    else {

        if ((TriggerIsEnabled(libSprt_gt_DEBUGDPSTracker) == true)) {

            TriggerEnable(libSprt_gt_DEBUGDPSTracker, false);

            TriggerEnable(libSprt_gt_DEBUGDPSTrackerTimerExpires, false);

            libSprt_gv_dEBUGDPSTrackerTrackingInterval = 0.0;

            libSprt_gv_dEBUGDPSTrackerTotalDamage = 0.0;

            libSprt_gv_dEBUGDPSTrackerTime = 0.0;

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_2FE6DEF4"), true);

        }

        else {

            TriggerEnable(libSprt_gt_DEBUGDPSTracker, true);

            TriggerEnable(libSprt_gt_DEBUGDPSTrackerTimerExpires, true);

            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_4721DE54"), true);

            libSprt_gv_dEBUGDPSTrackerTrackingInterval = StringToFixed(StringSub(EventChatMessage(false), 13, 14));

            TextExpressionSetToken("Param/Expression/lib_Sprt_05C0C86B", "A", StringExternal("Param/Value/lib_Sprt_A026A1A1"));

            TextExpressionSetToken("Param/Expression/lib_Sprt_05C0C86B", "B", FixedToText(libSprt_gv_dEBUGDPSTrackerTrackingInterval, c_fixedPrecisionAny));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_05C0C86B"), true);

            TimerStart(libSprt_gv_dEBUGDPSTrackerTimer, libSprt_gv_dEBUGDPSTrackerTrackingInterval, false, c_timeGame);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGStartDPSTracker_Init () {

    libSprt_gt_DEBUGStartDPSTracker = TriggerCreate("libSprt_gt_DEBUGStartDPSTracker_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGStartDPSTracker, c_playerAny, "-dpstracker", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - DPS Tracker

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDPSTracker_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }



        if (!((UnitHasBehavior2(EventUnitDamageSourceUnit(), "DPSTracker") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGDPSTrackerTotalDamage += EventUnitDamageAmount();

    UnitGroupAdd(libSprt_gv_dEBUGDPSTrackerGroup, EventUnitDamageSourceUnit());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDPSTracker_Init () {

    libSprt_gt_DEBUGDPSTracker = TriggerCreate("libSprt_gt_DEBUGDPSTracker_Func");

    TriggerEnable(libSprt_gt_DEBUGDPSTracker, false);

    TriggerAddEventUnitDamaged(libSprt_gt_DEBUGDPSTracker, null, c_unitDamageTypeAny, c_unitDamageEither, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Clear DPS Tracker Stats

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGClearDPSTrackerStats_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((TriggerIsEnabled(libSprt_gt_DEBUGDPSTracker) == true))) {

            return false;

        }



        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGDPSTrackerTotalDamage = 0.0;

    libSprt_gv_dEBUGDPSTrackerTime = 0.0;

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_F5F8B601"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGClearDPSTrackerStats_Init () {

    libSprt_gt_DEBUGClearDPSTrackerStats = TriggerCreate("libSprt_gt_DEBUGClearDPSTrackerStats_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGClearDPSTrackerStats, c_playerAny, "-dpsclear", true);

    TriggerAddEventKeyPressed(libSprt_gt_DEBUGClearDPSTrackerStats, c_playerAny, c_keyNumPad5, true, c_keyModifierStateIgnore, c_keyModifierStateIgnore, c_keyModifierStateIgnore);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - DPS Tracker Timer Expires

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDPSTrackerTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_dEBUGDPSTrackerTime += libSprt_gv_dEBUGDPSTrackerTrackingInterval;

    TimerStart(libSprt_gv_dEBUGDPSTrackerTimer, libSprt_gv_dEBUGDPSTrackerTrackingInterval, false, c_timeGame);

    TextExpressionSetToken("Param/Expression/lib_Sprt_CFB925D0", "A", StringExternal("Param/Value/lib_Sprt_47699D4A"));

    TextExpressionSetToken("Param/Expression/lib_Sprt_CFB925D0", "B", FixedToText(libSprt_gv_dEBUGDPSTrackerTotalDamage, 0));

    TextExpressionSetToken("Param/Expression/lib_Sprt_CFB925D0", "C", FixedToText((libSprt_gv_dEBUGDPSTrackerTotalDamage / libSprt_gv_dEBUGDPSTrackerTime), 0));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Sprt_CFB925D0"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDPSTrackerTimerExpires_Init () {

    libSprt_gt_DEBUGDPSTrackerTimerExpires = TriggerCreate("libSprt_gt_DEBUGDPSTrackerTimerExpires_Func");

    TriggerEnable(libSprt_gt_DEBUGDPSTrackerTimerExpires, false);

    TriggerAddEventTimer(libSprt_gt_DEBUGDPSTrackerTimerExpires, libSprt_gv_dEBUGDPSTrackerTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Temp

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGTemp_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_Sprt_36737449"));

    TriggerExecute(libStEx_gt_SE_TrainingModeReferenceCardDisplay, false, false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGTemp_Init () {

    libSprt_gt_DEBUGTemp = TriggerCreate("libSprt_gt_DEBUGTemp_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGTemp, c_playerAny, "DEBUGTEMP", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Don't Start

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGDontStart_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libNtve_gf_StopTimer(libGame_gv_openTheGatesTimer);

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_Sprt_36895C0E"));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGDontStart_Init () {

    libSprt_gt_DEBUGDontStart = TriggerCreate("libSprt_gt_DEBUGDontStart_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGDontStart, c_playerAny, "dontstart", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Enable Building Scaling

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGEnableBuildingScaling_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;

    int lv_itTeam;



    // Automatic Variable Declarations

    const int autoFF997C2D_ae = libCore_gv_bALMaxTeams;

    const int autoFF997C2D_ai = 1;

    unitgroup auto3B862A54_g;

    int auto3B862A54_u;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itTeam = 1;

    for ( ; ( (autoFF997C2D_ai >= 0 && lv_itTeam <= autoFF997C2D_ae) || (autoFF997C2D_ai < 0 && lv_itTeam >= autoFF997C2D_ae) ) ; lv_itTeam += autoFF997C2D_ai ) {

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL2Standalone", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3200.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL2Standalone", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3200.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL2", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3200.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL2", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3200.0);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "CannonTowerL2Damage", "Amount", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 110.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownTownHallL2", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 9550.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownTownHallL2", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 9550.0);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TownHallL2WeaponDamage", "Amount", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 160.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMoonwellL2", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 1900.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMoonwellL2", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 1900.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL3Standalone", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3800.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL3Standalone", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3800.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL3", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3800.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownCannonTowerL3", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 3800.0);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "CannonTowerL3Damage", "Amount", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 133.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownTownHallL3", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 11500.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownTownHallL3", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 11500.0);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TownHallL3WeaponDamage", "Amount", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 175.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMoonwellL3", "LifeStart", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 2240.0);

        CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMoonwellL3", "LifeMax", libGame_gf_ComputerPlayerInTeam(lv_itTeam), 2240.0);

        auto3B862A54_g = UnitGroup(null, libGame_gf_ComputerPlayerInTeam(lv_itTeam), RegionEntireMap(), UnitFilter((1 << c_targetFilterStructure), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

        auto3B862A54_u = UnitGroupCount(auto3B862A54_g, c_unitCountAll);

        for (;; auto3B862A54_u -= 1) {

            lv_itUnit = UnitGroupUnitFromEnd(auto3B862A54_g, auto3B862A54_u);

            if (lv_itUnit == null) { break; }

            if (((UnitHasBehavior2(lv_itUnit, "TownGateBehavior") == true) && (UnitHasBehavior2(lv_itUnit, "TownGateL3Behavior") == false))) {

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLifeMax, 3950.0);

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLife, 3950.0);

            }



            if (((UnitHasBehavior2(lv_itUnit, "TownGateBehavior") == true) && (UnitHasBehavior2(lv_itUnit, "TownGateL3Behavior") == true))) {

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLifeMax, 4400.0);

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLife, 4400.0);

            }



            if (((UnitHasBehavior2(lv_itUnit, "TownWallBehavior") == true) && (UnitHasBehavior2(lv_itUnit, "TownWallL3Behavior") == false))) {

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLifeMax, 1500.0);

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLife, 1500.0);

            }



            if (((UnitHasBehavior2(lv_itUnit, "TownWallBehavior") == true) && (UnitHasBehavior2(lv_itUnit, "TownWallL3Behavior") == true))) {

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLifeMax, 1650.0);

                UnitSetPropertyFixed(lv_itUnit, c_unitPropLife, 1650.0);

            }



        }

    }

    if ((libGame_gv_buildingScalingEnabled == true)) {

        libGame_gv_buildingScalingEnabled = false;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_8AE19A4E"), true);

    }

    else {

        libGame_gv_buildingScalingEnabled = true;

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_18FB7138"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGEnableBuildingScaling_Init () {

    libSprt_gt_DEBUGEnableBuildingScaling = TriggerCreate("libSprt_gt_DEBUGEnableBuildingScaling_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEnableBuildingScaling, c_playerAny, "BUILDINGSCALING", true);

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEnableBuildingScaling, c_playerAny, "-BUILDINGSCALING", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Enable town hall detection

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGEnabletownhalldetection_Func (bool testConds, bool runActions) {

    // Variable Declarations

    const string lv_detectionBuff_C = "CoreDetection";

    int lv_townIndex;

    unit lv_townHall;

    bool lv_truesightApplied;



    // Automatic Variable Declarations

    int autoEF48957F_ae;

    const int autoEF48957F_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    autoEF48957F_ae = libGame_gv_townTownCount;

    lv_townIndex = 1;

    for ( ; ( (autoEF48957F_ai >= 0 && lv_townIndex <= autoEF48957F_ae) || (autoEF48957F_ai < 0 && lv_townIndex >= autoEF48957F_ae) ) ; lv_townIndex += autoEF48957F_ai ) {

        lv_townHall = libGame_gf_TownTownHall(lv_townIndex);

        if ((UnitHasBehavior2(lv_townHall, lv_detectionBuff_C) == true)) {

            UnitBehaviorRemove(lv_townHall, lv_detectionBuff_C, 1);

            lv_truesightApplied = false;

        }

        else {

            UnitBehaviorAdd(lv_townHall, lv_detectionBuff_C, lv_townHall, 1);

            lv_truesightApplied = true;

        }

    }

    if ((lv_truesightApplied == true)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_7E6A20C4"), true);

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Sprt_D832791D"), true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGEnabletownhalldetection_Init () {

    libSprt_gt_DEBUGEnabletownhalldetection = TriggerCreate("libSprt_gt_DEBUGEnabletownhalldetection_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGEnabletownhalldetection, c_playerAny, "truesight", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Toggle EUPT Logging

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGToggleEUPTLogging_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((StringWord(EventChatMessage(false), 1) == "-eupt"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((StringWord(EventChatMessage(false), 2) == "on")) {

        ConsoleCommand("variable logfps 1", true, true);

        ConsoleCommand("PerfLibAutolog 1 1000", true, true);

    }

    else if ((StringWord(EventChatMessage(false), 2) == "off")) {

        ConsoleCommand("variable logfps 0", true, true);

        ConsoleCommand("PerfLibAutolog 0 1000", true, true);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGToggleEUPTLogging_Init () {

    libSprt_gt_DEBUGToggleEUPTLogging = TriggerCreate("libSprt_gt_DEBUGToggleEUPTLogging_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGToggleEUPTLogging, c_playerAny, "-eupt", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Get Base Unit Stats

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGGetBaseUnitStats_Func (bool testConds, bool runActions) {

    // Variable Declarations

    text lv_baseHealth;

    text lv_baseHealthRegen;

    text lv_baseHealthScaling;

    text lv_weaponDamage;

    unit lv_selectedUnit;



    // Automatic Variable Declarations

    unitgroup auto8C3F4A95_g;

    int auto8C3F4A95_u;

    unit auto8C3F4A95_var;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto8C3F4A95_g = UnitGroupSelected(EventPlayer());

    auto8C3F4A95_u = UnitGroupCount(auto8C3F4A95_g, c_unitCountAll);

    for (;; auto8C3F4A95_u -= 1) {

        auto8C3F4A95_var = UnitGroupUnitFromEnd(auto8C3F4A95_g, auto8C3F4A95_u);

        if (auto8C3F4A95_var == null) { break; }

        lv_selectedUnit = auto8C3F4A95_var;

        if ((UnitGetType(lv_selectedUnit) == "HeroMonk")) {

            lv_baseHealth = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogUnit, UnitGetType(lv_selectedUnit), "LifeStart", 0), c_fixedPrecisionAny);

            lv_baseHealthRegen = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogUnit, UnitGetType(lv_selectedUnit), "LifeRegenRate", 0), c_fixedPrecisionAny);

            lv_baseHealthScaling = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogHero, PlayerHero(EventPlayer()), "LevelScalingArray[" + IntToString(6) + "].Modifications[" + IntToString(1) + "].Value", 0), c_fixedPrecisionAny);

            lv_weaponDamage = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogEffect, CatalogFieldValueGet(c_gameCatalogWeapon, UnitWeaponGet(lv_selectedUnit, 1), "DisplayEffect", c_playerAny), "Amount", 0), c_fixedPrecisionAny);

        }

        else if (true) {

            lv_baseHealth = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogUnit, UnitGetType(lv_selectedUnit), "LifeStart", 0), c_fixedPrecisionAny);

            lv_baseHealthRegen = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogUnit, UnitGetType(lv_selectedUnit), "LifeRegenRate", 0), c_fixedPrecisionAny);

            lv_baseHealthScaling = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogHero, PlayerHero(EventPlayer()), "LevelScalingArray[" + IntToString(1) + "].Modifications[" + IntToString(0) + "].Value", 0), c_fixedPrecisionAny);

            lv_weaponDamage = FixedToText(CatalogFieldValueGetAsFixed(c_gameCatalogEffect, CatalogFieldValueGet(c_gameCatalogWeapon, UnitWeaponGet(lv_selectedUnit, 1), "DisplayEffect", c_playerAny), "Amount", 0), c_fixedPrecisionAny);

        }

        UIDisplayMessage(PlayerGroupActive(), c_messageAreaChat, (StringExternal("Param/Value/lib_Sprt_89ADB976") + UnitGetName(auto8C3F4A95_var)));

        UIDisplayMessage(PlayerGroupActive(), c_messageAreaChat, (StringExternal("Param/Value/lib_Sprt_A078F9E7") + lv_baseHealth + StringExternal("Param/Value/lib_Sprt_93620BFF") + lv_baseHealthRegen + StringExternal("Param/Value/lib_Sprt_889CD47C") + lv_baseHealthScaling));

        UIDisplayMessage(PlayerGroupActive(), c_messageAreaChat, (StringExternal("Param/Value/lib_Sprt_E4C07289") + lv_weaponDamage));

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGGetBaseUnitStats_Init () {

    libSprt_gt_DEBUGGetBaseUnitStats = TriggerCreate("libSprt_gt_DEBUGGetBaseUnitStats_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGGetBaseUnitStats, c_playerAny, "-gbs", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Wizard to Sappers

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGWizardtoSappers_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_composition;

    int lv_group;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_group = 2;



    // Conditions

    if (testConds) {

        if (!(((libCore_gv_dEBUGDebuggingEnabled == true) || (GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libSprt_gv_dEBUGSapperMinionsEnabled == false)) {

        libSprt_gv_dEBUGSapperMinionsEnabled = true;

        lv_composition = (libCore_ge_MinionWaveCompositionsTypes_Standard);

        libCore_gf_DataInitializeScalingDataForMinion("MercGoblinSapperLaner", libCore_ge_MinionTypes_Wizard);

        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Wizard;

        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/lib_Sprt_F2C49B06"));

    }

    else {

        libSprt_gv_dEBUGSapperMinionsEnabled = false;

        lv_composition = (libCore_ge_MinionWaveCompositionsTypes_Standard);

        libCore_gf_DataInitializeScalingDataForMinion("WizardMinion", libCore_ge_MinionTypes_Wizard);

        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Wizard;

        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/lib_Sprt_AB6B812E"));

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGWizardtoSappers_Init () {

    libSprt_gt_DEBUGWizardtoSappers = TriggerCreate("libSprt_gt_DEBUGWizardtoSappers_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGWizardtoSappers, c_playerAny, "-sappers", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sapper Health Globes

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSapperHealthGlobes_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_owner;

    int lv_regenGlobeOwner;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libSprt_gv_dEBUGSapperMinionsEnabled == true))) {

            return false;

        }



        if (!((UnitGetType(EventUnit()) == "MercGoblinSapperLaner"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_owner = UnitGetOwner(EventUnit());

    if ((lv_owner == libCore_gv_cOMPUTER_TeamOrder)) {

        lv_regenGlobeOwner = libCore_gv_cOMPUTER_TeamChaos;

    }

    else {

        lv_regenGlobeOwner = libCore_gv_cOMPUTER_TeamOrder;

    }

    libNtve_gf_CreateUnitsWithDefaultFacing(1, "RegenGlobe", c_unitCreateIgnorePlacement, lv_regenGlobeOwner, UnitGetPosition(EventUnit()), null);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSapperHealthGlobes_Init () {

    libSprt_gt_DEBUGSapperHealthGlobes = TriggerCreate("libSprt_gt_DEBUGSapperHealthGlobes_Func");

    TriggerAddEventUnitDied(libSprt_gt_DEBUGSapperHealthGlobes, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sapper Suicide Damage

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSapperSuicideDamage_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_amount;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libSprt_gv_dEBUGSapperMinionsEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_amount = StringToFixed(StringSub(EventChatMessage(false), 15, 19));

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "MercLanerGoblinSapperStructureSuicideDamage", "Amount", libStEx_gv_pLAYER_11_ORDER, lv_amount);

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "MercLanerGoblinSapperStructureSuicideDamage", "Amount", libStEx_gv_pLAYER_12_CHAOS, lv_amount);

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Sprt_994D2C73") + FixedToText(lv_amount, c_fixedPrecisionAny)));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSapperSuicideDamage_Init () {

    libSprt_gt_DEBUGSapperSuicideDamage = TriggerCreate("libSprt_gt_DEBUGSapperSuicideDamage_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSapperSuicideDamage, c_playerAny, "-sapperdamage", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sapper Attack Damage

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSapperAttackDamage_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_amount;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libSprt_gv_dEBUGSapperMinionsEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_amount = StringToFixed(StringSub(EventChatMessage(false), 15, 19));

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "MercLanerGoblinSapperDamage", "Amount", libStEx_gv_pLAYER_11_ORDER, lv_amount);

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "MercLanerGoblinSapperDamage", "Amount", libStEx_gv_pLAYER_12_CHAOS, lv_amount);

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Sprt_37A8E363") + FixedToText(lv_amount, c_fixedPrecisionAny)));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSapperAttackDamage_Init () {

    libSprt_gt_DEBUGSapperAttackDamage = TriggerCreate("libSprt_gt_DEBUGSapperAttackDamage_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSapperAttackDamage, c_playerAny, "-sapperattack", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Sapper Health

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGSapperHealth_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_amount;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libSprt_gv_dEBUGSapperMinionsEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_amount = StringToFixed(StringSub(EventChatMessage(false), 15, 19));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "MercGoblinSapperLaner", "LifeStart", libStEx_gv_pLAYER_11_ORDER, lv_amount);

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "MercGoblinSapperLaner", "LifeMax", libStEx_gv_pLAYER_11_ORDER, lv_amount);

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "MercGoblinSapperLaner", "LifeStart", libStEx_gv_pLAYER_12_CHAOS, lv_amount);

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "MercGoblinSapperLaner", "LifeMax", libStEx_gv_pLAYER_12_CHAOS, lv_amount);

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Sprt_AF23E390") + FixedToText(lv_amount, c_fixedPrecisionAny)));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGSapperHealth_Init () {

    libSprt_gt_DEBUGSapperHealth = TriggerCreate("libSprt_gt_DEBUGSapperHealth_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGSapperHealth, c_playerAny, "-sapperhealth", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Apply Armor Value Change

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGApplyArmorValueChange_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup auto00D6CE5D_g;

    int auto00D6CE5D_u;

    unit auto00D6CE5D_var;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto00D6CE5D_g = UnitGroupSelected(EventPlayer());

    auto00D6CE5D_u = UnitGroupCount(auto00D6CE5D_g, c_unitCountAll);

    for (;; auto00D6CE5D_u -= 1) {

        auto00D6CE5D_var = UnitGroupUnitFromEnd(auto00D6CE5D_g, auto00D6CE5D_u);

        if (auto00D6CE5D_var == null) { break; }

        if ((UnitHasBehavior2(auto00D6CE5D_var, "DebugDummyBehavior") == false)) {

            UnitBehaviorAdd(auto00D6CE5D_var, "DebugDummyBehavior", auto00D6CE5D_var, 1);

        }



        if ((StringToFixed(StringWord(EventChatMessage(false), 2)) != 0.0)) {

            libSprt_gv_dEBUGBaselineArmorValue = StringToFixed(StringWord(EventChatMessage(false), 2));

        }

        else {

            libSprt_gv_dEBUGBaselineArmorValue = 0.0;

        }

        CatalogFieldValueModifyFixed(c_gameCatalogBehavior, "DebugDummyBehavior", "ArmorModification.AllArmorBonus", UnitGetOwner(auto00D6CE5D_var), libSprt_gv_dEBUGBaselineArmorValue, c_upgradeOperationSet);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGApplyArmorValueChange_Init () {

    libSprt_gt_DEBUGApplyArmorValueChange = TriggerCreate("libSprt_gt_DEBUGApplyArmorValueChange_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGApplyArmorValueChange, c_playerAny, "-armor ", false);

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Apply Spell Power Value Change

//--------------------------------------------------------------------------------------------------

bool libSprt_gt_DEBUGApplySpellPowerValueChange_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup auto708275C8_g;

    int auto708275C8_u;

    unit auto708275C8_var;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    auto708275C8_g = UnitGroupSelected(EventPlayer());

    auto708275C8_u = UnitGroupCount(auto708275C8_g, c_unitCountAll);

    for (;; auto708275C8_u -= 1) {

        auto708275C8_var = UnitGroupUnitFromEnd(auto708275C8_g, auto708275C8_u);

        if (auto708275C8_var == null) { break; }

        if ((UnitHasBehavior2(auto708275C8_var, "DebugDummyBehavior") == false)) {

            UnitBehaviorAdd(auto708275C8_var, "DebugDummyBehavior", auto708275C8_var, 1);

        }



        if ((StringToFixed(StringWord(EventChatMessage(false), 2)) != 0.0)) {

            libSprt_gv_dEBUGBaselineSpellPowerValue = (StringToFixed(StringWord(EventChatMessage(false), 2)) / 100.0);

        }

        else {

            libSprt_gv_dEBUGBaselineSpellPowerValue = 0.0;

        }

        CatalogFieldValueModifyFixed(c_gameCatalogBehavior, "DebugDummyBehavior", "Modification.UnifiedDamageDealtFraction[" + IntToString(2) + "]", UnitGetOwner(auto708275C8_var), libSprt_gv_dEBUGBaselineSpellPowerValue, c_upgradeOperationSet);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libSprt_gt_DEBUGApplySpellPowerValueChange_Init () {

    libSprt_gt_DEBUGApplySpellPowerValueChange = TriggerCreate("libSprt_gt_DEBUGApplySpellPowerValueChange_Func");

    TriggerAddEventChatMessage(libSprt_gt_DEBUGApplySpellPowerValueChange, c_playerAny, "-sp", false);

}



void libSprt_InitTriggers () {

    libSprt_gt_IncludeSupport_Init();

    libSprt_gt_AISpawningTest_Init();

    libSprt_gt_AutomatedBuildTest_Init();

    libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap_Init();

    libSprt_gt_PerformanceTestRunPerformanceTest_Init();

    libSprt_gt_PerformanceTestSetHeroChoices_Init();

    libSprt_gt_PerformanceTestGetFPS_Init();

    libSprt_gt_PerformanceTestOutputFPSToFile_Init();

    libSprt_gt_PerformanceTestMaintainHeroHealth_Init();

    libSprt_gt_DEBUGStatTrackingStartforPlayer_Init();

    libSprt_gt_DEBUGStatTrackingLogBreak_Init();

    libSprt_gt_DEBUGStatTrackingStop_Init();

    libSprt_gt_DEBUGStatTrackingStartTrackingforAllPlayers_Init();

    libSprt_gt_DEBUGStatTrackingStopTrackingforAllPlayers_Init();

    libSprt_gt_StatTrackingDamageTracking_Init();

    libSprt_gt_StatTrackingHealingTracking_Init();

    libSprt_gt_StatTrackingGameOver_Init();

    libSprt_gt_DataMiningListenForRegenGlobes_Init();

    libSprt_gt_DataMiningPeriodicDataSendPeriodicEventTrigger_Init();

    libSprt_gt_DEBUGForceHeroMasteryRing0_Init();

    libSprt_gt_DEBUGForceHeroMasteryRing1_Init();

    libSprt_gt_DEBUGForceHeroMasteryRing2_Init();

    libSprt_gt_DEBUGForceHeroMasteryRing3_Init();

    libSprt_gt_DEBUGForceHeroMasteryRingRando_Init();

    libSprt_gt_QACheatsInit_Init();

    libSprt_gt_ToggleCheatsDialog_Init();

    libSprt_gt_QACheatsCloseButtonClicked_Init();

    libSprt_gt_QACheatsAlliedControlCheckboxClicked_Init();

    libSprt_gt_QACheatsShowMapCheckboxClicked_Init();

    libSprt_gt_QACheatsVisionCheckboxClicked_Init();

    libSprt_gt_QACheatsCooldownsCheckboxClicked_Init();

    libSprt_gt_QACheatsGridCheckboxClicked_Init();

    libSprt_gt_QACheatsVisualizeEffectsCheckboxClicked_Init();

    libSprt_gt_QACheatsToggleFreeCheckboxClicked_Init();

    libSprt_gt_QACheatsToggleSelectionCheckboxClicked_Init();

    libSprt_gt_QACheatsToggleDisableWeaponsCheckboxChecked_Init();

    libSprt_gt_QACheatsDisableWeaponsOnSpawn_Init();

    libSprt_gt_QACheatsDisableWeaponsOnChenUlt_Init();

    libSprt_gt_QACheatsUnitSelected_Init();

    libSprt_gt_QACheatsBehaviorDropdownSelectionChange_Init();

    libSprt_gt_QACheatsBehaviorApplyButtonClicked_Init();

    libSprt_gt_QACheatsBehaviorRemoveButtonClicked_Init();

    libSprt_gt_QACheatsBehaviorCleanseButtonClicked_Init();

    libSprt_gt_QACheatsExecuteSpeedButtonClicked_Init();

    libSprt_gt_QACheatsSpawnUnitsDropdownSelectionChange_Init();

    libSprt_gt_QACheatsTeamCheckboxesClicked_Init();

    libSprt_gt_QACheatsSpawnUnitsButtonClicked_Init();

    libSprt_gt_QACheatsDebugKillUnitButtonClicked_Init();

    libSprt_gt_QACheatsRefreshUnitButtonClicked_Init();

    libSprt_gt_QACheatsMoveUnitButtonClicked_Init();

    libSprt_gt_QACheatsRefreshCooldownsButtonClicked_Init();

    libSprt_gt_QACheatsSetCameraAngleButtonClicked_Init();

    libSprt_gt_QACheatsToggleDebugCameraCheckboxChecked_Init();

    libSprt_gt_QACheatsSpawnItemButtonClicked_Init();

    libSprt_gt_QACheatsRespawnStructuresButtonClicked_Init();

    libSprt_gt_QACheatsKillStructuresButtonClicked_Init();

    libSprt_gt_QACheatsDebugRespawnButtonClicked_Init();

    libSprt_gt_DEBUGIntroVOInteractorItemintrovotest_Init();

    libSprt_gt_DEBUGIntroVOInteractorUsage_Init();

    libSprt_gt_DEBUGInspectTheBalanceProbebalanceprobe_Init();

    libSprt_gt_DEBUGResetTheBalanceProbebalancereset_Init();

    libSprt_gt_DEBUGTimedBalanceProbebalancetimer_Init();

    libSprt_gt_DEBUGBalanceProbeTimerExpires_Init();

    libSprt_gt_DEBUGEnableSoundRepeat_Init();

    libSprt_gt_DEBUGSoundRepeatAdjustDelay_Init();

    libSprt_gt_DEBUGSoundRepeatAbilityUsed_Init();

    libSprt_gt_DEBUGPassiveExpBalancerpassivebalance_Init();

    libSprt_gt_DEBUGWhichplayersareAIwhoisai_Init();

    libSprt_gt_DEBUGEqualizeExperienceeqxp_Init();

    libSprt_gt_DEBUGBoostExperienceeqexpboost_Init();

    libSprt_gt_DEBUGXPTrickleOnlyxptrickleonly_Init();

    libSprt_gt_DEBUGSuppressDebugMessages_Init();

    libSprt_gt_DEBUGXPHeroxphero_Init();

    libSprt_gt_DEBUGXPMinionxpminion_Init();

    libSprt_gt_DEBUGXPStructurexpstructure_Init();

    libSprt_gt_DEBUGXPCreepxpcreep_Init();

    libSprt_gt_DEBUGHelphelp_Init();

    libSprt_gt_DEBUGPlayerNumberplayernum_Init();

    libSprt_gt_DEBUGToggleSelectiontogselection_Init();

    libSprt_gt_DEBUGToggleShowXPValuestogshowxpvalues_Init();

    libSprt_gt_DEBUGStartGamestartgame_Init();

    libSprt_gt_DEBUGDisablePingLimitfreepings_Init();

    libSprt_gt_DEBUGPauseGameStartTimerpausestart_Init();

    libSprt_gt_DEBUGTurnOnNormalCreepCampscreepcamp_Init();

    libSprt_gt_DEBUGRespawnCreepCampsrespawncamps_Init();

    libSprt_gt_DEBUGSpawnHerospawnhero_Init();

    libSprt_gt_DEBUGRespawnHerodebugrespawn_Init();

    libSprt_gt_DEBUGSelectHerodebugselect_Init();

    libSprt_gt_DEBUGKillHerodebugkill_Init();

    libSprt_gt_DEBUGAIHeroMimicheromimic_Init();

    libSprt_gt_DEBUGAISetHerosethero_Init();

    libSprt_gt_DEBUGAISetAllHerosetallheroes_Init();

    libSprt_gt_DEBUGLogRandomHeroesForPlayer_Init();

    libSprt_gt_DEBUGLevelAIHerosheroxp_Init();

    libSprt_gt_DEBUGToggleFloatingCombatTexttogcombattext_Init();

    libSprt_gt_DEBUGToggleMinionSpawningtogminionspawn_Init();

    libSprt_gt_DEBUGToggleMinionSystemPausedtogminionpause_Init();

    libSprt_gt_DEBUGToggleMinionSystemOnOfftogminionsystem_Init();

    libSprt_gt_DEBUGToggleMinionBonusXPOnOff_Init();

    libSprt_gt_DEBUGToggleTowerSystemOnOfftogtowersystem_Init();

    libSprt_gt_DEBUGTowerSystemOntowerson_Init();

    libSprt_gt_DEBUGTowerSystemOfftowersoff_Init();

    libSprt_gt_DEBUGToggleXPTrickletogtrickle_Init();

    libSprt_gt_DEBUGScalecatchupXPBonuscatchupxpbonus_Init();

    libSprt_gt_DEBUGScalecatchupXPPenaltycatchupxppenalty_Init();

    libSprt_gt_DEBUGToggleSoloXPtogsoloxp_Init();

    libSprt_gt_DEBUGScaleCampscampscale_Init();

    libSprt_gt_DEBUGHaveAITakeOverAI_Init();

    libSprt_gt_DEBUGHaveAITakeOverAIAll_Init();

    libSprt_gt_DEBUGHaveAITakeOverAIAllOff_Init();

    libSprt_gt_DEBUGHaveAITakeOverAIAllOn_Init();

    libSprt_gt_DEBUGAIShowTalentBuildaishowtalentbuild_Init();

    libSprt_gt_DEBUGAICycleThroughAllHeroesailoadeveryhero_Init();

    libSprt_gt_DEBUGDisplayHeroAIDebugInfoaidebug_Init();

    libSprt_gt_DEBUGDisplayDefenderAIDebugInfodefenderdebug_Init();

    libSprt_gt_DEBUGVictorydebugvictory_Init();

    libSprt_gt_DEBUGStructures1ShotMinionskillerstructures_Init();

    libSprt_gt_DEBUGIncreasedMinionDamagekillerminions_Init();

    libSprt_gt_DEBUGRefreshCooldownscdr_Init();

    libSprt_gt_DEBUGDefeatdebugdefeat_Init();

    libSprt_gt_DEBUGUpvotedebugupvote_Init();

    libSprt_gt_DEBUGTiedebugtie_Init();

    libSprt_gt_DEBUGToggleHeroAItogheroai_Init();

    libSprt_gt_DEBUGStopAIThinkTree_Init();

    libSprt_gt_DEBUGStartAIThinkTree_Init();

    libSprt_gt_DEBUGStopRegenstopregen_Init();

    libSprt_gt_DEBUGStopHealthRegenForAllPlayersnoregen_Init();

    libSprt_gt_DEBUGToggleCoreShieldMechanictogcoreshield_Init();

    libSprt_gt_DEBUGToggleDebugOutputtogdebug_Init();

    libSprt_gt_DEBUGToggleForCinematicstogcine_Init();

    libSprt_gt_DEBUGToggleForMapTexttogmaptext_Init();

    libSprt_gt_DEBUGTurnOffWeather_Init();

    libSprt_gt_DEBUGTurnOnMinionSpellResist_Init();

    libSprt_gt_DEBUGCompleteAllQuests_Init();

    libSprt_gt_DEBUGProgressAllQuests_Init();

    libSprt_gt_DEBUGTeamFightPerfTest_Init();

    libSprt_gt_DEBUGToggleJungleCampDebugtogcampdebug_Init();

    libSprt_gt_DEBUGTargetJungleCreepState_Init();

    libSprt_gt_DEBUG60SecondPause_Init();

    libSprt_gt_DEBUGTriggerASave_Init();

    libSprt_gt_DEBUGHeroIsAlive_Init();

    libSprt_gt_DEBUGShortHeroDeath_Init();

    libSprt_gt_DEBUGInvulnerableStructures_Init();

    libSprt_gt_DEBUGRespawnStructures_Init();

    libSprt_gt_DEBUGKillStructures_Init();

    libSprt_gt_DEBUGCollectStructureData_Init();

    libSprt_gt_DEBUGGameTime_Init();

    libSprt_gt_DEBUGChooseTalent_Init();

    libSprt_gt_DEBUGXPRange_Init();

    libSprt_gt_DEBUGAfkSystem_Init();

    libSprt_gt_DEBUGStartDPSTracker_Init();

    libSprt_gt_DEBUGDPSTracker_Init();

    libSprt_gt_DEBUGClearDPSTrackerStats_Init();

    libSprt_gt_DEBUGDPSTrackerTimerExpires_Init();

    libSprt_gt_DEBUGTemp_Init();

    libSprt_gt_DEBUGDontStart_Init();

    libSprt_gt_DEBUGEnableBuildingScaling_Init();

    libSprt_gt_DEBUGEnabletownhalldetection_Init();

    libSprt_gt_DEBUGToggleEUPTLogging_Init();

    libSprt_gt_DEBUGGetBaseUnitStats_Init();

    libSprt_gt_DEBUGWizardtoSappers_Init();

    libSprt_gt_DEBUGSapperHealthGlobes_Init();

    libSprt_gt_DEBUGSapperSuicideDamage_Init();

    libSprt_gt_DEBUGSapperAttackDamage_Init();

    libSprt_gt_DEBUGSapperHealth_Init();

    libSprt_gt_DEBUGApplyArmorValueChange_Init();

    libSprt_gt_DEBUGApplySpellPowerValueChange_Init();

}



//--------------------------------------------------------------------------------------------------

// Library Initialization

//--------------------------------------------------------------------------------------------------

bool libSprt_InitLib_completed = false;



void libSprt_InitLib () {

    if (libSprt_InitLib_completed) {

        return;

    }



    libSprt_InitLib_completed = true;



    libSprt_InitLibraries();

    libSprt_InitVariables();

    libSprt_InitTriggers();

}



include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/MapMechanicsLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"

include "TriggerLibs/StartingExperienceLib"

include "TriggerLibs/SoundLib"

include "TriggerLibs/GameDataHelperLib"